Built with Alectryon, running Coq+SerAPI v8.15.0+0.15.0. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus. On Mac, use instead of Ctrl.
From Coq Require Import ssreflect ssrfun ssrbool.

From Ltac2 Require Import Ltac2.

From Coq Require Import Ensembles Bool String.

From Coq.Logic Require Import FunctionalExtensionality Eqdep_dec.
From Equations Require Import Equations.

Require Import Coq.Program.Tactics.

From MatchingLogic Require Import Syntax DerivedOperators_Syntax ProofSystem IndexManipulation wftactics.

New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
From MatchingLogic.Utils Require Import stdpp_ext. Import extralibrary. From MatchingLogic Require Import Logic ProofInfo ProofMode_base ProofMode_propositional ProofMode_firstorder ProofMode_fixpoint ProofMode_reshaper BasicProofSystemLemmas . Import MatchingLogic.Logic.Notations. Set Default Proof Mode "Classic". Open Scope ml_scope. Open Scope string_scope. Open Scope list_scope. Ltac2 _callCompletedTransformedAndCast (t : constr) (transform : constr) (tac : constr -> unit) := let tac' := (fun (t' : constr) => let tac'' := (fun (t'' : constr) => let tcast := open_constr:(@useGenericReasoning'' _ _ _ _ _ $t'') in fillWithUnderscoresAndCall tac tcast [] ) in fillWithUnderscoresAndCall (fun t''' => tac'' t''') transform [t'] ) in fillWithUnderscoresAndCall tac' t [] . Ltac2 mlApplyMetaGeneralized (t : constr) := _callCompletedTransformedAndCast t constr:(@reshape_lhs_imp_to_and_forward) _mlApplyMetaRaw ; try_solve_pile_basic (); try_wfa () . Ltac _mlApplyMetaGeneralized t := _ensureProofMode; let ff := ltac2:(t' |- mlApplyMetaGeneralized (Option.get (Ltac1.to_constr(t')))) in ff t; rewrite [foldr patt_and _ _]/= . Tactic Notation "mlApplyMeta" constr(t) := (mlApplyMeta t) || (_mlApplyMetaGeneralized t) .
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern

well_formed a → well_formed b → well_formed c → well_formed d → well_formed e → well_formed f → Γ ⊢ a ---> b ---> c ---> d ---> e ---> f → Γ ⊢ a and b and c and d and e ---> f
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern

well_formed a → well_formed b → well_formed c → well_formed d → well_formed e → well_formed f → Γ ⊢ a ---> b ---> c ---> d ---> e ---> f → Γ ⊢ a and b and c and d and e ---> f
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f

Γ ⊢ a and b and c and d and e ---> f
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f

well_formed (a and b and c and d and e ---> f)
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f
Γ Ⱶ a and b and c and d and e ---> f
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f

well_formed (a and b and c and d and e ---> f)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f

Γ Ⱶ a and b and c and d and e ---> f
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f

Γ Ⱶ "H1" ∶ a and b and c and d and e, -------------------------------------- f
Σ: Signature
Γ: Theory
a, b, c, d, e, f: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
H: Γ ⊢ a ---> b ---> c ---> d ---> e ---> f

Γ Ⱶ "H1" ∶ a and b and c and d and e, -------------------------------------- a and b and c and d and e
mlExact "H1". Defined.
i: bool
l: list bool

foldr andb i l = true → i = true
i: bool
l: list bool

foldr andb i l = true → i = true
l: list bool

i : bool, foldr andb i l = true → i = true
i: bool
H: i = true

i = true
a: bool
l: list bool
IHl: i : bool, foldr andb i l = true → i = true
i: bool
H: a && foldr andb i l = true
i = true
i: bool
H: i = true

i = true
assumption.
a: bool
l: list bool
IHl: i : bool, foldr andb i l = true → i = true
i: bool
H: a && foldr andb i l = true

i = true
a: bool
l: list bool
IHl: i : bool, foldr andb i l = true → i = true
i: bool
H: a && foldr andb i l = true

i = true
a: bool
l: list bool
IHl: i : bool, foldr andb i l = true → i = true
i: bool
H: a = true ∧ foldr andb i l = true

i = true
a: bool
l: list bool
IHl: i : bool, foldr andb i l = true → i = true
i: bool
H1: a = true
H2: foldr andb i l = true

i = true
a: bool
l: list bool
IHl: i : bool, foldr andb i l = true → i = true
i: bool
H1: a = true
H2: foldr andb i l = true

foldr andb i l = true
exact H2. } Qed.
i: bool
l: list bool

foldr andb i l = i && foldr andb true l
i: bool
l: list bool

foldr andb i l = i && foldr andb true l
l: list bool

i : bool, foldr andb i l = i && foldr andb true l
i: bool

i = i && true
a: bool
l: list bool
IHl: i : bool, foldr andb i l = i && foldr andb true l
i: bool
a && foldr andb i l = [&& i, a & foldr andb true l]
i: bool

i = i && true
i: bool

i = i
reflexivity.
a: bool
l: list bool
IHl: i : bool, foldr andb i l = i && foldr andb true l
i: bool

a && foldr andb i l = [&& i, a & foldr andb true l]
a: bool
l: list bool
IHl: i : bool, foldr andb i l = i && foldr andb true l
i: bool

a && foldr andb i l = [&& i, a & foldr andb true l]
a: bool
l: list bool
IHl: i : bool, foldr andb i l = i && foldr andb true l
i: bool

[&& a, i & foldr andb true l] = [&& i, a & foldr andb true l]
a: bool
l: list bool
IHl: i : bool, foldr andb i l = i && foldr andb true l
i: bool

a && i && foldr andb true l = i && a && foldr andb true l
a: bool
l: list bool
IHl: i : bool, foldr andb i l = i && foldr andb true l
i: bool

i && a && foldr andb true l = i && a && foldr andb true l
reflexivity. } Qed.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern

r : ImpReshapeS g' (x :: xs), Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i → Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern

r : ImpReshapeS g' (x :: xs), Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i → Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i

Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i ))
Hwf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i )))

mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i )
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))

well_formed {| irs_flattened := f; irs_pf := pf |}
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))

well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb (well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂))) (map well_formed (map nh_patt l₁))

well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
Hwf1: well_formed g'
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) = true

well_formed (foldr patt_imp g' (x :: xs))
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))) (map well_formed (map nh_patt l₁))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb (well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂))) (map well_formed (map nh_patt l₁))

foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))) (map well_formed (map nh_patt l₁))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: foldr andb (well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂))) (map well_formed (map nh_patt l₁))

foldr andb (well_formed f && foldr andb true (map well_formed (map nh_patt l₂))) (map well_formed (map nh_patt l₁))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))

foldr andb (well_formed f && foldr andb true (map well_formed (map nh_patt l₂))) (map well_formed (map nh_patt l₁))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))

well_formed f && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Hwf2: foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂))) && foldr andb true (map well_formed (map nh_patt l₁))

well_formed x
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x

wf xs
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x

wf xs
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

wf xs
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

wf xs
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

wf xs
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
Hwf2: foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂))) && foldr andb true (map well_formed (map nh_patt l₁))

wf xs
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

well_formed (foldr patt_and x xs)
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
assumption.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂))) && foldr andb true (map well_formed (map nh_patt l₁))

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ f) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ map nh_patt ((name ∶ f) :: l₂)) using i

wf (map nh_patt l₁) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
H0: well_formed x
H1: wf xs
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ map nh_patt ((name ∶ f) :: l₂)) using i
wffa: foldr andb true (map well_formed (map nh_patt l₁ ++ map nh_patt ((name ∶ f) :: l₂)))

wf (map nh_patt l₁) = true
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb true (map well_formed (map nh_patt l₁) ++ map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb (foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂)))) (map well_formed (map nh_patt l₁))

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = foldr patt_imp g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed {| irs_flattened := f; irs_pf := pf |}
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ {| irs_flattened := f; irs_pf := pf |}) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: foldr andb true (map well_formed (map nh_patt ((name ∶ foldr patt_imp g' (x :: xs)) :: l₂))) && foldr andb true (map well_formed (map nh_patt l₁))

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ f) :: l₂)) using i
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ f) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ map nh_patt ((name ∶ f) :: l₂)) using i

wf (map nh_patt l₂) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
f: TaggedPattern
pf: f = (x ---> foldr patt_imp g' xs)
Hwf1: well_formed g'
wfr: well_formed f
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwf2: well_formed (x ---> foldr patt_imp g' xs) && foldr andb true (map well_formed (map nh_patt l₂)) && foldr andb true (map well_formed (map nh_patt l₁))
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ map nh_patt ((name ∶ f) :: l₂)) using i
wffa: foldr andb true (map well_formed (map nh_patt l₁ ++ map nh_patt ((name ∶ f) :: l₂)))

wf (map nh_patt l₂) = true
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ map nh_patt ((name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ map nh_patt ((name ∶ r) :: l₂)) using i

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ foldr patt_imp g' (x :: xs) :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed ?h
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i foldr patt_imp g' (x :: xs) ---> ?h using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ ?h :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp g' (x :: xs) ---> ?h using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp g' (x :: xs) ---> ?h using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf xs
1-3: wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_and x xs ---> g')
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ (foldr patt_and x xs ---> g') :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ (foldr patt_and x xs ---> g') :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ (foldr patt_and x xs ---> g') :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ (foldr patt_and x xs ---> g') :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed ?h
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_and x xs ---> g')
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i (foldr patt_and x xs ---> g') ---> ?h using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ ?h :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i (foldr patt_and x xs ---> g') ---> ?h using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i (foldr patt_and x xs ---> g') ---> ?h using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf xs
1-3: wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
wf (map nh_patt l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_imp g' (x :: xs))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_and x xs ---> g')
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i
Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ foldr patt_imp g' (x :: xs) :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ r :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ foldr patt_imp g' (x :: xs) :: map nh_patt l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Hwf1: well_formed g'
Hwf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wfr: well_formed r
wffa: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
H0: well_formed x
H1: wf xs
Hwfl₁: wf (map nh_patt l₁) = true
Hwfl₂: wf (map nh_patt l₂) = true
H: Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ foldr patt_imp g' (x :: xs) :: map nh_patt l₂) using i

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt l₁ ++ foldr patt_imp g' (x :: xs) :: map nh_patt l₂) using i
exact H. Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern

r : ImpReshapeS g' (x :: xs), Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i → Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern

r : ImpReshapeS g' (x :: xs), Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i → Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i

Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i

Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

well_formed match rev xs with | [] => x | yk :: ys => x and foldr patt_and yk (rev ys) end
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

well_formed match rev xs with | [] => x | yk :: ys => x and foldr patt_and yk (rev ys) end
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Heqxs: rev xs = []

well_formed x
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Heqxs: rev xs = []

well_formed x
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l

well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l

well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
p: Pattern
l: list Pattern
Heqxs: rev (rev xs) = rev (p :: l)

well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
p: Pattern
l: list Pattern
Heqxs: xs = rev (p :: l)

well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
p: Pattern
l: list Pattern
Heqxs: xs = rev l ++ [p]

well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x (rev l ++ [p]) using i )))
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x (rev l ++ [p]) using i ))

well_formed (x and foldr patt_and p (rev l))
wf_auto2. }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))
Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: mlTheory (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- match rev xs with | [] => x | yk :: ys => foldr patt_and yk (x :: rev ys) end using i )
wf1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i ))
wf2: wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ r) :: l₂-------------------------------------- foldr patt_and x xs using i )))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp match rev xs with | [] => x | yk :: ys => x and foldr patt_and yk (rev ys) end (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Heqxs: rev xs = []
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Heqxs: rev xs = []
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
Heqxs: rev (rev xs) = rev []
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = rev []

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = []

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
r: ImpReshapeS g' [x]
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x [])
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ ⊢i foldr patt_imp (foldr patt_and x []) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
r: ImpReshapeS g' [x]
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed x
H: Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ ⊢i foldr patt_imp x (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
exact H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev xs = p :: l
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
Heqxs: rev (rev xs) = rev (p :: l)
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = rev (p :: l)

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x: Pattern
xs: list Pattern
r: ImpReshapeS g' (x :: xs)
p: Pattern
l: list Pattern
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
wf1: well_formed (foldr patt_and x xs)
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
Heqxs: xs = rev l ++ [p]

Γ ⊢i foldr patt_imp (foldr patt_and x xs) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ ⊢i foldr patt_imp (foldr patt_and x (rev l ++ [p])) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
well_formed ?g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
well_formed (foldr patt_and x (rev l ++ [p]))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Γ ⊢i ?g ---> foldr patt_and x (rev l ++ [p]) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Γ ⊢i foldr patt_imp ?g (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
well_formed (foldr patt_and x (rev l ++ [p]))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Γ ⊢i x and foldr patt_and p (rev l) ---> foldr patt_and x (rev l ++ [p]) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ ⊢i x and foldr patt_and p (rev l) ---> foldr patt_and x (rev l ++ [p]) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ ⊢i x and foldr patt_and p (rev l) ---> foldr patt_and (foldr patt_and x [p]) (rev l) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ ⊢i x and foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

well_formed (x and foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Γ Ⱶ x and foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

well_formed (x and foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ Ⱶ x and foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ Ⱶ "H1" ∶ x and foldr patt_and p (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ Ⱶ "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ Ⱶ "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), "Hw'" ∶ foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))
Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), "Hw'" ∶ foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), -------------------------------------- p ---> p and x using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), "Hp" ∶ p, -------------------------------------- p and x using BasicReasoning
mlSplitAnd;[mlExact "Hp" | mlExact "Hx"].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hw" ∶ (p ---> p and x) ---> foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), "Hw'" ∶ foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), "Hw'" ∶ foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), -------------------------------------- foldr patt_and (p and x) (rev l) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
Hwf: well_formed (foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l))

Γ Ⱶ "Hx" ∶ x, "Hf" ∶ foldr patt_and p (rev l), "Hw'" ∶ foldr patt_and p (rev l) ---> foldr patt_and (p and x) (rev l), -------------------------------------- foldr patt_and p (rev l) using BasicReasoning
mlExact "Hf".
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i

wf (map nh_patt (l₁ ++ (name ∶ r) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
well_formed (x and foldr patt_and p (rev l))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g': Pattern
i: ProofInfo
x, p: Pattern
l: list Pattern
r: ImpReshapeS g' (x :: rev l ++ [p])
wf2: foldr andb true (map well_formed (map nh_patt (l₁ ++ (name ∶ r) :: l₂)))
wf1: well_formed (foldr patt_and x (rev l ++ [p]))
H: Γ ⊢i foldr patt_imp (x and foldr patt_and p (rev l)) (map nh_patt (l₁ ++ (name ∶ r) :: l₂)) using i
well_formed (foldr patt_and x (rev l ++ [p]))
1,2,3: wf_auto2. } Defined. Tactic Notation "_mlApplyBasic" constr(name') := _ensureProofMode; _mlReshapeHypsByName name'; apply MLGoal_weakenConclusion; _mlReshapeHypsBack; cbn. Tactic Notation "_mlApplyGen" constr(name') := _ensureProofMode; _mlReshapeHypsByName name'; apply MLGoal_weakenConclusionGen; _mlReshapeHypsBack; cbn.
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern

well_formed a → well_formed b → well_formed c → well_formed d → well_formed e → well_formed f → well_formed g → Γ ⊢ a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern

well_formed a → well_formed b → well_formed c → well_formed d → well_formed e → well_formed f → well_formed g → Γ ⊢ a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ ⊢ a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

well_formed (a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g)
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g
Γ Ⱶ a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

well_formed (a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ Ⱶ a and b and c and d and e ---> (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ Ⱶ "H1" ∶ a and b and c and d and e, -------------------------------------- (a ---> b ---> c ---> d ---> e ---> f) ---> (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ Ⱶ "H1" ∶ a and b and c and d and e, "H2" ∶ a ---> b ---> c ---> d ---> e ---> f, -------------------------------------- (f ---> g) ---> g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ Ⱶ "H1" ∶ a and b and c and d and e, "H2" ∶ a ---> b ---> c ---> d ---> e ---> f, "H3" ∶ f ---> g, -------------------------------------- g
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ Ⱶ "H1" ∶ a and b and c and d and e, "H2" ∶ a ---> b ---> c ---> d ---> e ---> f, "H3" ∶ f ---> g, -------------------------------------- f
Σ: Signature
Γ: Theory
a, b, c, d, e, f, g: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
wfd: well_formed d
wfe: well_formed e
wff: well_formed f
wfg: well_formed g

Γ Ⱶ "H1" ∶ a and b and c and d and e, "H2" ∶ a ---> b ---> c ---> d ---> e ---> f, "H3" ∶ f ---> g, -------------------------------------- a and b and c and d and e
mlExact "H1". Defined. Tactic Notation "mlApply" constr(name') := (_mlApplyBasic name') || (_mlApplyGen name') . Section FOL_helpers. Context {Σ : Signature}.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

Γ ⊢i ϕ₁ ---> ϕ₂ using i → Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

Γ ⊢i ϕ₁ ---> ϕ₂ using i → Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

Γ ⊢i ϕ₁ $ ψ ---> ϕ₂ $ ψ using i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ML_proof_system Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ) ?pf i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ML_proof_system Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

well_formed ψ
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

well_formed ψ
exact wfψ.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ML_proof_system Γ (ϕ₁ ---> ϕ₂)
exact pf.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ) (Framing_left Γ ϕ₁ ϕ₂ ψ wfψ pf) i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ) (Framing_left Γ ϕ₁ ϕ₂ ψ wfψ pf) i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

ProofInfoMeaning Γ (ϕ₁ $ ψ ---> ϕ₂ $ ψ) (Framing_left Γ ϕ₁ ϕ₂ ψ wfψ pf) i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
assumption.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
assumption.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

uses_kt pf ==> pi_uses_kt i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

uses_kt pf ==> pi_uses_kt i
assumption. } } Defined.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

Γ ⊢i ϕ₁ ---> ϕ₂ using i → Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

Γ ⊢i ϕ₁ ---> ϕ₂ using i → Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

Γ ⊢i ψ $ ϕ₁ ---> ψ $ ϕ₂ using i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ML_proof_system Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂) ?pf i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ML_proof_system Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

well_formed ψ
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i
ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

well_formed ψ
exact wfψ.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ML_proof_system Γ (ϕ₁ ---> ϕ₂)
exact pf.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂) (Framing_right Γ ϕ₁ ϕ₂ ψ wfψ pf) i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf: ProofInfoMeaning Γ (ϕ₁ ---> ϕ₂) pf i

ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂) (Framing_right Γ ϕ₁ ϕ₂ ψ wfψ pf) i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

ProofInfoMeaning Γ (ψ $ ϕ₁ ---> ψ $ ϕ₂) (Framing_right Γ ϕ₁ ϕ₂ ψ wfψ pf) i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
assumption.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i
uses_kt pf ==> pi_uses_kt i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
assumption.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

uses_kt pf ==> pi_uses_kt i
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
i: ProofInfo
wfψ: well_formed ψ
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
pf: ML_proof_system Γ (ϕ₁ ---> ϕ₂)
Hpf1: gset_to_coGset (uses_of_ex_gen Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_generalized_evars i
Hpf2: gset_to_coGset (uses_of_svar_subst Γ (ϕ₁ ---> ϕ₂) pf) ⊆ pi_substituted_svars i
Hpf3: uses_kt pf ==> pi_uses_kt i

uses_kt pf ==> pi_uses_kt i
assumption. } } Defined.
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i ⊥ $ ϕ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ML_proof_system Γ (⊥ $ ϕ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (⊥ $ ϕ ---> ⊥) ?pf BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ML_proof_system Γ (⊥ $ ϕ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed ϕ
exact wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ProofInfoMeaning Γ (⊥ $ ϕ ---> ⊥) (Prop_bott_left Γ ϕ wfϕ) BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ProofInfoMeaning Γ (⊥ $ ϕ ---> ⊥) (Prop_bott_left Γ ϕ wfϕ) BasicReasoning
abstract(solve_pim_simple). } Defined.
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i ϕ $ ⊥ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ML_proof_system Γ (ϕ $ ⊥ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
ProofInfoMeaning Γ (ϕ $ ⊥ ---> ⊥) ?pf BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ML_proof_system Γ (ϕ $ ⊥ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed ϕ
exact wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ProofInfoMeaning Γ (ϕ $ ⊥ ---> ⊥) (Prop_bott_right Γ ϕ wfϕ) BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

ProofInfoMeaning Γ (ϕ $ ⊥ ---> ⊥) (Prop_bott_right Γ ϕ wfϕ) BasicReasoning
abstract(solve_pim_simple). } Defined. Arguments Prop_bott_left _ (_%ml) _ : clear implicits. Arguments Prop_bott_right _ (_%ml) _ : clear implicits.
Σ: Signature
Γ: Theory
C: Application_context

Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context

Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory

Γ ⊢i ⊥ ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory

Γ ⊢i ⊥ ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory

Γ ⊢i ⊥ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory

well_formed ⊥
wf_auto2.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i C.[□↦⊥] $ p ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (C.[□↦⊥] $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ?B using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i ?B ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i ?B ---> ⊥ using BasicReasoning
apply (Prop_bott_left Γ p ltac:(wf_auto2)).
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (C.[□↦⊥] $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (⊥ $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] $ p ---> ⊥ $ p using ?i'
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (C.[□↦⊥] $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (⊥ $ p)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
all: try solve [wf_auto2].
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p $ C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> ?B using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i ?B ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i ?B ---> ⊥ using BasicReasoning
apply (Prop_bott_right Γ p ltac:(wf_auto2)).
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ ⊥)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p $ C.[□↦⊥] ---> p $ ⊥ using ?i'
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i C.[□↦⊥] ---> ⊥ using ?i'
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ ⊥)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (p $ C.[□↦⊥])
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (p $ ⊥)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
IHC: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
1-2: try_solve_pile. Defined.
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i

Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)

Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
HWF: well_formed (A ---> B)

Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
HWF: well_formed (A ---> B)
wfA: well_formed A

Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
pf: ML_proof_system Γ (A ---> B)
HWF: well_formed (A ---> B)
wfA: well_formed A
wfB: well_formed B

Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
H: Γ ⊢i A ---> B using i
wfA: well_formed A
wfB: well_formed B

Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
C: Application_context
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i

Γ ⊢i A ---> B using i
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using i
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i
Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i

Γ ⊢i A ---> B using i
exact H.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i

Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using i
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

Γ ⊢i C.[□↦A] $ p ---> C.[□↦B] $ p using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
try_solve_pile.
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

well_formed A
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
well_formed B
Σ: Signature
Γ: Theory
C: Application_context
p: Pattern
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
1-3: assumption.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i C.[□↦A] ---> C.[□↦B] using i
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using i

Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using i
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

Γ ⊢i p $ C.[□↦A] ---> p $ C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
try_solve_pile.
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)

well_formed A
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
well_formed B
Σ: Signature
Γ: Theory
p: Pattern
C: Application_context
Prf: well_formed p
A, B: Pattern
pi_generalized_evars: coEVarSet
pi_substituted_svars: coSVarSet
pi_uses_kt: bool
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
IHC: well_formed A → well_formed B → Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt) → Γ ⊢i C.[□↦A] ---> C.[□↦B] using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
Γ ⊢i A ---> B using (ExGen := pi_generalized_evars, SVSubst := pi_substituted_svars, KT := pi_uses_kt)
1-3: assumption. Defined.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

well_formed A → Γ ⊢i A using i → Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

well_formed A → Γ ⊢i A using i → Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! ! A using i

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i

Γ ⊢i ! C.[□↦! A] using i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
TRANS:= syllogism_meta ?Goal0 ?Goal1 ?Goal2 EF PB: Γ ⊢i C.[□↦! A] ---> ⊥ using i

Γ ⊢i ! C.[□↦! A] using i
apply TRANS.
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i

well_formed A
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦! A]
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦⊥]
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A using i
ANNA: Γ ⊢i ! A ---> ⊥ using i
EF: Γ ⊢i C.[□↦! A] ---> C.[□↦⊥] using i
PB: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed ⊥
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
H2: true = true
H0: well_formed_positive A = true
H1: well_formed_closed_ex_aux A 0 = true
H4: well_formed_closed_mu_aux A 0 = true

∅ ⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
A: Pattern
C: Application_context
i: ProofInfo
H2: true = true
H0: well_formed_positive A = true
H1: well_formed_closed_ex_aux A 0 = true
H4: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_substituted_svars i
all: set_solver. Defined.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

well_formed A → Γ ⊢i A ---> ⊥ using i → Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i

well_formed A → Γ ⊢i A ---> ⊥ using i → Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i

Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i

Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i

Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i

Γ ⊢i C.[□↦A] ---> ⊥ using i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
TRANS: Γ ⊢i C.[□↦A] ---> ⊥ using i

Γ ⊢i C.[□↦A] ---> ⊥ using i
exact TRANS.
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦A]
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed C.[□↦⊥]
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
pile: ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
WFA: well_formed A
H: Γ ⊢i A ---> ⊥ using i
FR: Γ ⊢i C.[□↦A] ---> C.[□↦⊥] using i
BPR: Γ ⊢i C.[□↦⊥] ---> ⊥ using i
well_formed ⊥
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
H2: true = true
H1: well_formed_positive A = true
H3: well_formed_closed_ex_aux A 0 = true
H0: well_formed_closed_mu_aux A 0 = true

∅ ⊆ pi_generalized_evars i
Σ: Signature
Γ: Theory
C: Application_context
A: Pattern
i: ProofInfo
H2: true = true
H1: well_formed_positive A = true
H3: well_formed_closed_ex_aux A 0 = true
H0: well_formed_closed_mu_aux A 0 = true
∅ ⊆ pi_substituted_svars i
all: set_solver. Defined. End FOL_helpers.
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i AC.[□↦⊥] <---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i AC.[□↦⊥] <---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

well_formed AC.[□↦⊥]
Σ: Signature
Γ: Theory
AC: Application_context
well_formed ⊥
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i AC.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i AC.[□↦⊥] ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
well_formed ⊥
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

well_formed ⊥
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i ⊥ ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i ⊥ ---> ⊥ using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i ⊥ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
AC: Application_context

well_formed ⊥
reflexivity.
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i ⊥ ---> AC.[□↦⊥] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context

Γ ⊢i ⊥ ---> AC.[□↦⊥] using BasicReasoning
Σ: Signature
Γ: Theory
AC: Application_context

well_formed AC.[□↦⊥]
wf_auto2. } Defined.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern

well_formed ϕ₁ → well_formed ϕ₂ → well_formed ψ → Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern

well_formed ϕ₁ → well_formed ϕ₂ → well_formed ψ → Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

Γ ⊢i (ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ML_proof_system Γ ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ) ?pf BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ML_proof_system Γ ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ)
apply Prop_disj_left; assumption.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ProofInfoMeaning Γ ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ) (Prop_disj_left Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ) BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ProofInfoMeaning Γ ((ϕ₁ or ϕ₂) $ ψ ---> ϕ₁ $ ψ or ϕ₂ $ ψ) (Prop_disj_left Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ) BasicReasoning
abstract (solve_pim_simple). } Defined.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern

well_formed ϕ₁ → well_formed ϕ₂ → well_formed ψ → Γ ⊢i ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern

well_formed ϕ₁ → well_formed ϕ₂ → well_formed ψ → Γ ⊢i ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

Γ ⊢i ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ML_proof_system Γ (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂) ?pf BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ML_proof_system Γ (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂)
apply Prop_disj_right; assumption.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ProofInfoMeaning Γ (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂) (Prop_disj_right Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ) BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂, ψ: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
wfψ: well_formed ψ

ProofInfoMeaning Γ (ψ $ (ϕ₁ or ϕ₂) ---> ψ $ ϕ₁ or ψ $ ϕ₂) (Prop_disj_right Γ ϕ₁ ϕ₂ ψ wfϕ₁ wfϕ₂ wfψ) BasicReasoning
abstract (solve_pim_simple). } Defined.
Σ: Signature
Γ: Theory
AC: Application_context
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p or q <---> p or q using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p or q] $ p0 <---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ AC.[□↦p or q] <---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p or q <---> p or q using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p or q <---> p or q using BasicReasoning
apply pf_iff_equiv_refl; wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p or q] $ p0 <---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: ((Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)) * (Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)))%type

Γ ⊢i AC.[□↦p or q] $ p0 <---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p or q] $ p0 <---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦p or q] $ p0 <---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
Γ ⊢i AC.[□↦p] $ p0 or AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
ProofInfoLe i i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

ProofInfoLe i i
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
apply pile_refl.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p or q] $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (AC.[□↦p or q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] $ p0 or AC.[□↦q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p or q] $ p0 ---> ?B using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed (AC.[□↦p or q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ((AC.[□↦p] or AC.[□↦q]) $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] $ p0 or AC.[□↦q] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i (AC.[□↦p] or AC.[□↦q]) $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i (AC.[□↦p] or AC.[□↦q]) $ p0 ---> AC.[□↦p] $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or AC.[□↦q] using i
IH2: Γ ⊢i p' or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i (p' or AC.[□↦q]) $ p0 ---> p' $ p0 or AC.[□↦q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using i
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i (p' or q') $ p0 ---> p' $ p0 or q' $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i (p' or q') $ p0 ---> p' $ p0 or q' $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe ?i' (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i (p' or q') $ p0 ---> p' $ p0 or q' $ p0 using ?i'
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe BasicReasoning (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p'
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed q'
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (p' or q') $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe BasicReasoning (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
H: Γ ⊢i AC.[□↦p or q] $ p0 ---> (AC.[□↦p] or AC.[□↦q]) $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe BasicReasoning (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile. }
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦p] $ p0 or AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦p] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
Γ ⊢i AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦p] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] $ p0 ---> AC.[□↦p or q] $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> ?B using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i ?B ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q] using BasicReasoning
apply disj_left_intro; wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using i
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] $ p0 ---> AC.[□↦p or q] $ p0 using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> ?B using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q] using BasicReasoning
apply disj_right_intro; wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: Γ ⊢i AC.[□↦p or q] <---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦p or q] <---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IHAC: ((Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)) * (Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)))%type

Γ ⊢i p0 $ AC.[□↦p or q] <---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦p or q] <---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦p or q] <---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
Γ ⊢i p0 $ AC.[□↦p] or p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
ProofInfoLe i i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

ProofInfoLe i i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i

Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i

well_formed (p0 $ AC.[□↦p or q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p] or p0 $ AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i p0 $ AC.[□↦p or q] ---> ?B using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i ?B ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i

well_formed (p0 $ AC.[□↦p or q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ (AC.[□↦p] or AC.[□↦q]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
well_formed (p0 $ AC.[□↦p] or p0 $ AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i
Γ ⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i

Γ ⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
H: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (AC.[□↦p] or AC.[□↦q]) using i

Γ ⊢i p0 $ (AC.[□↦p] or AC.[□↦q]) ---> p0 $ AC.[□↦p] or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or AC.[□↦q] using i
IH2: Γ ⊢i p' or AC.[□↦q] ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or AC.[□↦q]) using i

Γ ⊢i p0 $ (p' or AC.[□↦q]) ---> p0 $ p' or p0 $ AC.[□↦q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using i
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using i
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q') using i

Γ ⊢i p0 $ (p' or q') ---> p0 $ p' or p0 $ q' using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q') using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ (p' or q') ---> p0 $ p' or p0 $ q' using BasicReasoning
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q') using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed p'
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q') using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed q'
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
p': Pattern
Heqp': p' = AC.[□↦p]
q': Pattern
Heqq': q' = AC.[□↦q]
H: Γ ⊢i p0 $ AC.[□↦p or q] ---> p0 $ (p' or q') using (ExGen := ∅, SVSubst := ∅, KT := false)
IH2: Γ ⊢i p' or q' ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> p' or q' using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed p0
all: subst; try_wfauto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦p] or p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i
Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦p] ---> p0 $ AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> ?B using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦p] ---> AC.[□↦p] or AC.[□↦q] using BasicReasoning
apply disj_left_intro; wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
i: ProofInfo
Heqi: i = (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using i
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using i

Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using i
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦q] ---> p0 $ AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := ∅, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> ?B using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

well_formed AC.[□↦q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed (AC.[□↦p] or AC.[□↦q])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
well_formed AC.[□↦p or q]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
IH2: Γ ⊢i AC.[□↦p] or AC.[□↦q] ---> AC.[□↦p or q] using (ExGen := ∅, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦p or q] ---> AC.[□↦p] or AC.[□↦q] using (ExGen := ∅, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦q] ---> AC.[□↦p] or AC.[□↦q] using BasicReasoning
apply disj_right_intro; wf_auto2. Defined.
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar

well_formed ϕ → Γ ⊢i ! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ]) using BasicReasoning
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar

well_formed ϕ → Γ ⊢i ! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ]) using BasicReasoning
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ

Γ ⊢i ! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ]) using BasicReasoning
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ

ML_proof_system Γ (! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ]))
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ
ProofInfoMeaning Γ (! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ])) ?pf BasicReasoning
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ

ML_proof_system Γ (! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ]))
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ

well_formed ϕ
apply Hwf.
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ

ProofInfoMeaning Γ (! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ])) (Singleton_ctx Γ C1 C2 ϕ x Hwf) BasicReasoning
Σ: Signature
Γ: Theory
C1, C2: Application_context
ϕ: Pattern
x: evar
Hwf: well_formed ϕ

ProofInfoMeaning Γ (! (C1.[□↦patt_free_evar x and ϕ] and C2.[□↦patt_free_evar x and ! ϕ])) (Singleton_ctx Γ C1 C2 ϕ x Hwf) BasicReasoning
abstract (solve_pim_simple). } Defined.
Σ: Signature
Γ: Theory

Γ ⊢i ex , b0 using BasicReasoning
Σ: Signature
Γ: Theory

Γ ⊢i ex , b0 using BasicReasoning
Σ: Signature
Γ: Theory

ML_proof_system Γ (ex , b0)
Σ: Signature
Γ: Theory
ProofInfoMeaning Γ (ex , b0) ?pf BasicReasoning
Σ: Signature
Γ: Theory

ML_proof_system Γ (ex , b0)
apply ProofSystem.Existence.
Σ: Signature
Γ: Theory

ProofInfoMeaning Γ (ex , b0) (Existence Γ) BasicReasoning
Σ: Signature
Γ: Theory

ProofInfoMeaning Γ (ex , b0) (Existence Γ) BasicReasoning
abstract (solve_pim_simple). } Defined.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern

well_formed (ex , ϕ) → well_formed ψ → Γ ⊢i (ex , ϕ) $ ψ ---> (ex , ϕ $ ψ) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern

well_formed (ex , ϕ) → well_formed ψ → Γ ⊢i (ex , ϕ) $ ψ ---> (ex , ϕ $ ψ) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

Γ ⊢i (ex , ϕ) $ ψ ---> (ex , ϕ $ ψ) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ML_proof_system Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ)) ?pf BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ML_proof_system Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ))
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed (ex , ϕ)
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed (ex , ϕ)
exact wfϕ.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed ψ
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed ψ
exact wfψ. }
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ProofInfoMeaning Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ)) (Prop_ex_left Γ ϕ ψ wfϕ wfψ) BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ProofInfoMeaning Γ ((ex , ϕ) $ ψ ---> (ex , ϕ $ ψ)) (Prop_ex_left Γ ϕ ψ wfϕ wfψ) BasicReasoning
abstract(solve_pim_simple). } Defined.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern

well_formed (ex , ϕ) → well_formed ψ → Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern

well_formed (ex , ϕ) → well_formed ψ → Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

Γ ⊢i ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ML_proof_system Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)) ?pf BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ML_proof_system Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ))
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed (ex , ϕ)
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ
well_formed ψ
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed (ex , ϕ)
exact wfϕ.
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed ψ
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

well_formed ψ
exact wfψ. }
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)) (Prop_ex_right Γ ϕ ψ wfϕ wfψ) BasicReasoning
Σ: Signature
Γ: Theory
ϕ, ψ: Pattern
wfϕ: well_formed (ex , ϕ)
wfψ: well_formed ψ

ProofInfoMeaning Γ (ψ $ (ex , ϕ) ---> (ex , ψ $ ϕ)) (Prop_ex_right Γ ϕ ψ wfϕ wfψ) BasicReasoning
abstract(solve_pim_simple). } Defined. Tactic Notation "change" "constraint" "in" ident(H) := let i := fresh "i" in remember_constraint as i; eapply useGenericReasoning with (i := i) in H; subst i; [|(try_solve_pile)].
Σ: Signature
Γ: Theory
AC: Application_context
p: Pattern
x: evar

evar_is_fresh_in x AC.[□↦p] → well_formed (ex , p) = true → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p: Pattern
x: evar

evar_is_fresh_in x AC.[□↦p] → well_formed (ex , p) = true → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p: Pattern
x: evar
Hx: evar_is_fresh_in x AC.[□↦p]
Hwf: well_formed (ex , p) = true

Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x □.[□↦p]
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x} using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x □.[□↦p]
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x} using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> exists_quantify x p^{evar:0↦x} using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> (ex , p^{evar:0↦x}^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> (ex , p) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true
well_formed_closed_ex_aux p 1
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> (ex , p) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true

Γ ⊢i (ex , p) <---> (ex , p) using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
x: evar
Hx: evar_is_fresh_in x p
Hwf: well_formed (ex , p) = true

well_formed (ex , p)
exact Hwf.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed_positive (ex , AC.[□↦p]) && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed_positive (ex , p) && well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed_positive p && well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed_positive p = true ∧ well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive p = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive AC.[□↦p] = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_positive AC.[□↦p] && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive AC.[□↦p] = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

true && well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfp: well_formed_positive AC.[□↦p] = true
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux (ex , AC.[□↦p]) 0 && well_formed_closed_ex_aux (ex , AC.[□↦p]) 0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux (ex , p) 0 && well_formed_closed_ex_aux (ex , p) 0 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux (ex , AC.[□↦p]) 0 && well_formed_closed_ex_aux (ex , AC.[□↦p]) 0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux (ex , AC.[□↦p]) 0 && well_formed_closed_ex_aux (ex , AC.[□↦p]) 0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux AC.[□↦p] 0 && well_formed_closed_ex_aux AC.[□↦p] 1
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux AC.[□↦p] 0 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true
well_formed_closed_ex_aux AC.[□↦p] 1 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux AC.[□↦p] 0 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux p 0 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
H: well_formed_closed_mu_aux p 0 = true
H0: well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_mu_aux p 0 = true
assumption.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_ex_aux AC.[□↦p] 1 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwfc: well_formed_closed_mu_aux p 0 && well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_ex_aux p 1 = true
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
H: well_formed_closed_mu_aux p 0 = true
H0: well_formed_closed_ex_aux p 1 = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwf': well_formed (ex , p) = true

well_formed_closed_ex_aux p 1 = true
assumption.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

free_evars AC.[□↦p] ⊆ free_evars ?ϕ₂
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x ?ϕ₂
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x ?ϕ₂
apply Hx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

free_evars AC.[□↦p] ⊆ free_evars (AC.[□↦p] $ p0)
solve_free_evars_inclusion 5.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC $ₗ p0).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1, Hxfr1': evar_is_fresh_in x AC.[□↦p]

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfr1': evar_is_fresh_in x p ∧ x ∉ AC_free_evars AC

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC

well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC

well_formed (ex , p) = true
apply Hwf.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])

well_formed p^{evar:0↦x}
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])

well_formed p^{evar:0↦x}
wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
(* TODO automate this. The problem is that [well_formed_app] and others do not have [= true]; that is why [auto] does not work. But [auto] is not suitable for this anyway. A better way would be to create some `simpl_well_formed` tuple, that might use the type class mechanism for extension... *)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}

well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}

well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IHAC: ((Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)) * (Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)))%type
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦ex , p] $ p0 <---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i AC.[□↦ex , p] $ p0 ---> ?B using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i exists_quantify x p' $ p0 ---> exists_quantify x (p' $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i (ex , p'^{{evar:x↦0}}) $ p0 ---> (ex , (p' $ p0)^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i (ex , p'^{{evar:x↦0}}) $ p0 ---> (ex , p'^{{evar:x↦0}} $ p0^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

evar_is_fresh_in x p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i (ex , p'^{{evar:x↦0}}) $ p0 ---> (ex , p'^{{evar:x↦0}} $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

evar_is_fresh_in x p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

evar_is_fresh_in x (?ϕ₁ $ p0)
apply Hx.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i (ex , p'^{{evar:x↦0}}) $ p0 ---> (ex , p'^{{evar:x↦0}} $ p0) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i (ex , p'^{{evar:x↦0}}) $ p0 ---> (ex , p'^{{evar:x↦0}} $ p0) using BasicReasoning
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , p'^{{evar:x↦0}})
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] $ p0 ---> exists_quantify x p' $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p' $ p0))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed p0
wf_auto2.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed ?B
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> ?B using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i ?B ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed (AC.[□↦ex , p] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0) ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
x ∉ free_evars (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦p^{evar:0↦x}] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦p^{evar:0↦x}] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars (exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars ((ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}) $ p0)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}} ∪ free_evars p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]} ∪ free_evars p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]} ∪ free_evars p0
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars AC.[□↦p] ∪ free_evars p0
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

x ∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]} ∪ free_evars p0
Σ: Signature
AC: Application_context
p0, p: Pattern
x: evar
Hx: x ∉ free_evars AC.[□↦p] ∪ free_evars p0

x ∉ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]} ∪ free_evars p0
set_solver.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p^{evar:0↦x}] $ p0 ---> exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
(* TODO have some nice implicit parameters *)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

ProofInfoLe ?i' (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using ?i'
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p^[evar:0↦patt_free_evar x]] ---> exists_quantify x AC.[□↦p^[evar:0↦patt_free_evar x]] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] ---> exists_quantify x AC.[□↦p]^[evar:0↦patt_free_evar x] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] ---> (ex , AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] ---> (ex , AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]^{evar:0↦x}^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))
well_formed_closed_ex_aux AC.[□↦p] 1
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
AC: Application_context
p0: Pattern
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (AC.[□↦p] $ p0)
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] $ p0 ---> AC.[□↦ex , p] $ p0 using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (AC.[□↦p^{evar:0↦x}] $ p0))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]) using BasicReasoning
apply Ex_quan; auto.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , AC.[□↦p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , AC.[□↦p])
wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x AC.[□↦p]
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

free_evars AC.[□↦p] ⊆ free_evars ?ϕ₂
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
evar_is_fresh_in x ?ϕ₂
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

evar_is_fresh_in x ?ϕ₂
apply Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])

free_evars AC.[□↦p] ⊆ free_evars (p0 $ AC.[□↦p])
solve_free_evars_inclusion 5.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ᵣ AC).[□↦p]
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1, Hxfr1': evar_is_fresh_in x AC.[□↦p]

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfr1': evar_is_fresh_in x p ∧ x ∉ AC_free_evars AC

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC

well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC

well_formed (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}})
Σ: Signature
AC: Application_context
p: Pattern
x: evar
Hwf: well_formed (ex , p) = true
HxAC: x ∉ AC_free_evars AC

well_formed (ex , p) = true
apply Hwf.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])

well_formed p^{evar:0↦x}
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])

well_formed p^{evar:0↦x}
wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
(* TODO automate this. The problem is that [well_formed_app] and others do not have [= true]; that is why [auto] does not work. But [auto] is not suitable for this anyway. A better way would be to create some `simpl_well_formed` tuple, that might use the type class mechanism for extension... *)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}

well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}

well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: evar_is_fresh_in x AC.[□↦p] → Γ ⊢i AC.[□↦ex , p] <---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IHAC: ((Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)) * (Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)))%type
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i p0 $ AC.[□↦ex , p] <---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i p0 $ AC.[□↦ex , p] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i p0 $ AC.[□↦ex , p] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦ex , p] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦ex , p] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦ex , p] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ AC.[□↦ex , p] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ AC.[□↦ex , p] ---> ?B using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i ?B ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ exists_quantify x p' ---> exists_quantify x (p0 $ p') using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ (ex , p'^{{evar:x↦0}}) ---> (ex , (p0 $ p')^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ (ex , p'^{{evar:x↦0}}) ---> (ex , p0^{{evar:x↦0}} $ p'^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

evar_is_fresh_in x p0
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Γ ⊢i p0 $ (ex , p'^{{evar:x↦0}}) ---> (ex , p0 $ p'^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

evar_is_fresh_in x p0
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

evar_is_fresh_in x (p0 $ ?ϕ₂)
apply Hx.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ (ex , p'^{{evar:x↦0}}) ---> (ex , p0 $ p'^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

Γ ⊢i p0 $ (ex , p'^{{evar:x↦0}}) ---> (ex , p0 $ p'^{{evar:x↦0}}) using BasicReasoning
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed (ex , p'^{{evar:x↦0}})
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
well_formed p0
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
p': Pattern
Heqp': p' = AC.[□↦p^{evar:0↦x}]
IH2: Γ ⊢i exists_quantify x p' ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH1: Γ ⊢i p0 $ AC.[□↦ex , p] ---> p0 $ exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x p')
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ p'))
H: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x p' using (ExGen := {[x]}, SVSubst := ∅, KT := false)

well_formed p0
wf_auto2.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH1: Γ ⊢i AC.[□↦ex , p] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed ?B
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> ?B using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i ?B ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed (p0 $ AC.[□↦ex , p])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i exists_quantify x AC.[□↦p^{evar:0↦x}] ---> AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]) ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
x ∉ free_evars (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i p0 $ AC.[□↦p^{evar:0↦x}] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
Γ ⊢i p0 $ AC.[□↦p^{evar:0↦x}] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars (p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}])
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars (p0 $ (ex , AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}))
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars p0 ∪ free_evars AC.[□↦p^{evar:0↦x}]^{{evar:x↦0}}
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars p0 ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars p0 ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: x ∉ free_evars p0 ∪ free_evars AC.[□↦p]
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

x ∉ free_evars p0 ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
Σ: Signature
p0: Pattern
AC: Application_context
p: Pattern
x: evar
Hx: x ∉ free_evars p0 ∪ free_evars AC.[□↦p]

x ∉ free_evars p0 ∪ free_evars AC.[□↦p^{evar:0↦x}] ∖ {[x]}
set_solver.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i p0 $ AC.[□↦p^{evar:0↦x}] ---> p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) (ExGen := {[x]}, SVSubst := ∅, KT := false)
try_solve_pile.
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p^{evar:0↦x}] ---> exists_quantify x AC.[□↦p^{evar:0↦x}] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p^[evar:0↦patt_free_evar x]] ---> exists_quantify x AC.[□↦p^[evar:0↦patt_free_evar x]] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] ---> exists_quantify x AC.[□↦p]^[evar:0↦patt_free_evar x] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] ---> (ex , AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^[evar:0↦patt_free_evar x] ---> (ex , AC.[□↦p]^[evar:0↦patt_free_evar x]^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]^{evar:0↦x}^{{evar:x↦0}}) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))
well_formed_closed_ex_aux AC.[□↦p] 1
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]) using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Σ: Signature
Γ: Theory
p0: Pattern
AC: Application_context
Prf: well_formed p0
p: Pattern
x: evar
Hx: evar_is_fresh_in x (p0 $ AC.[□↦p])
Hwf: well_formed (ex , p) = true
IH2: Γ ⊢i p0 $ exists_quantify x AC.[□↦p^{evar:0↦x}] ---> p0 $ AC.[□↦ex , p] using (ExGen := {[x]}, SVSubst := ∅, KT := false)
Hwfex: well_formed (ex , AC.[□↦p])
Hxfr1: evar_is_fresh_in x AC.[□↦p]
Hxfrp: evar_is_fresh_in x p
HxAC: x ∉ AC_free_evars AC
Hwf': well_formed (exists_quantify x AC.[□↦p^{evar:0↦x}])
Hwfeo: well_formed p^{evar:0↦x}
Hwf'p0: well_formed (exists_quantify x (p0 $ AC.[□↦p^{evar:0↦x}]))

Γ ⊢i AC.[□↦p]^{evar:0↦x} ---> (ex , AC.[□↦p]) using BasicReasoning
apply Ex_quan; auto. } Defined. Add Search Blacklist "_elim". Add Search Blacklist "_graph_rect". Add Search Blacklist "_graph_mut". Add Search Blacklist "FunctionalElimination_". Section FOL_helpers. Context {Σ : Signature}. (** NOTE: DO NOT REPLACE! The element variable in this function is needed to substitute in such pattern context, which contain arbitrary patterns, but the path to the element variable is concrete. For example, in `⌈ E ⌉ $ φ` the path to `E` does not contain any ∃-s, thus no new variables need to be generated for `mlRewrite`. *) Fixpoint maximal_exists_depth_to (depth : nat) (E : evar) (ψ : Pattern) : nat := match ψ with | patt_bott => 0 | patt_sym _ => 0 | patt_bound_evar _ => 0 | patt_bound_svar _ => 0 | patt_free_svar _ => 0 | patt_free_evar E' => match (decide (E' = E)) with | left _ => depth | right _ => 0 end | patt_imp ψ₁ ψ₂ => Nat.max (maximal_exists_depth_to depth E ψ₁) (maximal_exists_depth_to depth E ψ₂) | patt_app ψ₁ ψ₂ => Nat.max (maximal_exists_depth_to depth E ψ₁) (maximal_exists_depth_to depth E ψ₂) | patt_exists ψ' => maximal_exists_depth_to (S depth) E ψ' | patt_mu ψ' => maximal_exists_depth_to depth E ψ' end.
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_exists_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern

(E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}

(if decide (x = E) then depth else 0) = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}

(if decide (x = E) then depth else 0) = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
e: x = E
H: decide (x = E) = left e

depth = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n

0 = 0
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` 0 = 0
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` maximal_exists_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_exists_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_exists_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` 0 = 0
reflexivity.
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_exists_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_exists_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

0 = 0
reflexivity.
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_exists_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_exists_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_exists_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

0 = 0
reflexivity. } Qed.
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∈ free_evars ψ → maximal_exists_depth_to (S depth) E ψ = S (maximal_exists_depth_to depth E ψ)
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∈ free_evars ψ → maximal_exists_depth_to (S depth) E ψ = S (maximal_exists_depth_to depth E ψ)
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hin: E ∈ free_evars ψ

maximal_exists_depth_to (S depth) E ψ = S (maximal_exists_depth_to depth E ψ)
Σ: Signature
ψ: Pattern

(E : evar) (depth : nat), E ∈ free_evars ψ → maximal_exists_depth_to (S depth) E ψ = S (maximal_exists_depth_to depth E ψ)
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}

(if decide (x = E) then S depth else 0) = S (if decide (x = E) then depth else 0)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}

(if decide (x = E) then S depth else 0) = S (if decide (x = E) then depth else 0)
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
e: x = E
H: decide (x = E) = left e

S depth = S depth
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 1
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n

0 = 1
set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1) `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1) `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ2 = 0

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (0 `max` maximal_exists_depth_to depth E ψ2)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

False
set_solver. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1) `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1) `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ2 = 0

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_exists_depth_to depth E ψ2 = 0
n': maximal_exists_depth_to (S depth) E ψ2 = 0

S (maximal_exists_depth_to depth E ψ1) `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_exists_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_exists_depth_to (S depth) E ψ1 = 0

maximal_exists_depth_to (S depth) E ψ1 `max` S (maximal_exists_depth_to depth E ψ2) = S (0 `max` maximal_exists_depth_to depth E ψ2)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_exists_depth_to (S depth) E ψ1 `max` maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ1 `max` maximal_exists_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_exists_depth_to (S depth) E ψ1 = S (maximal_exists_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_exists_depth_to (S depth) E ψ2 = S (maximal_exists_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

False
set_solver. } } Qed.
Σ: Signature
φ: Pattern
depth: nat
x, e: evar

dbi : db_index, x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
depth: nat
x, e: evar

dbi : db_index, x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
x, e: evar

(depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e

maximal_exists_depth_to depth x match compare_nat n HeNq with | Nat_less _ _ _ => patt_bound_evar n | Nat_equal _ _ _ => patt_free_evar e | Nat_greater _ _ _ => patt_bound_evar (Nat.pred n) end = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦ patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0

maximal_exists_depth_to depth x (patt_free_evar e) = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦ patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0

(if decide (e = x) then depth else 0) = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦ patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
e1: e = x
H1: decide (e = x) = left e1

depth = 0
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
n0: e ≠ x
H1: decide (e = x) = right n0
0 = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦ patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
n: db_index
x, e: evar
depth: nat
HeNq: db_index
H: x ≠ e
e0: n = HeNq
H0: compare_nat n HeNq = Nat_equal n HeNq e0
n0: e ≠ x
H1: decide (e = x) = right n0

0 = 0
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦ patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e

maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x, e: evar
IHφ1: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ1^{evar:dbi↦e} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ2^{evar:dbi↦e} = maximal_exists_depth_to depth x φ2
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ1^[evar:HeNq↦patt_free_evar e] `max` maximal_exists_depth_to depth x φ2^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e

maximal_exists_depth_to (S depth) x φ^[evar:S HeNq↦patt_free_evar e] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e
maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
x, e: evar
IHφ: (depth : nat) (dbi : db_index), x ≠ e → maximal_exists_depth_to depth x φ^{evar:dbi↦e} = maximal_exists_depth_to depth x φ
depth: nat
HeNq: db_index
H: x ≠ e

maximal_exists_depth_to depth x φ^[evar:HeNq↦patt_free_evar e] = maximal_exists_depth_to depth x φ
rewrite IHφ; auto. Qed.
Σ: Signature
φ: Pattern
depth: nat
x: evar
X: svar

dbi : db_index, maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
depth: nat
x: evar
X: svar

dbi : db_index, maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
x: evar
X: svar

(depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
Σ: Signature
n: db_index
x: evar
X: svar
depth: nat
dbi: db_index

maximal_exists_depth_to depth x match compare_nat n dbi with | Nat_less _ _ _ => patt_bound_svar n | Nat_equal _ _ _ => patt_free_svar X | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n) end = 0
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ1^{svar:dbi↦X} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ2^{svar:dbi↦X} = maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x φ1^[svar:dbi↦patt_free_svar X] `max` maximal_exists_depth_to depth x φ2^[svar:dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ1^{svar:dbi↦X} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ2^{svar:dbi↦X} = maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x φ1^[svar:dbi↦patt_free_svar X] `max` maximal_exists_depth_to depth x φ2^[svar:dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to (S depth) x φ^[svar:dbi↦ patt_free_svar X] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x φ^[svar:S dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ1^{svar:dbi↦X} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ2^{svar:dbi↦X} = maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index

maximal_exists_depth_to depth x φ1^[svar:dbi↦patt_free_svar X] `max` maximal_exists_depth_to depth x φ2^[svar:dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ1, φ2: Pattern
x: evar
X: svar
IHφ1: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ1^{svar:dbi↦X} = maximal_exists_depth_to depth x φ1
IHφ2: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ2^{svar:dbi↦X} = maximal_exists_depth_to depth x φ2
depth: nat
dbi: db_index
maximal_exists_depth_to depth x φ1^[svar:dbi↦patt_free_svar X] `max` maximal_exists_depth_to depth x φ2^[svar:dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ1 `max` maximal_exists_depth_to depth x φ2
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to (S depth) x φ^[svar:dbi↦patt_free_svar X] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x φ^[svar:S dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index

maximal_exists_depth_to (S depth) x φ^[svar:dbi↦patt_free_svar X] = maximal_exists_depth_to (S depth) x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index
maximal_exists_depth_to depth x φ^[svar:S dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ
Σ: Signature
φ: Pattern
x: evar
X: svar
IHφ: (depth : nat) (dbi : db_index), maximal_exists_depth_to depth x φ^{svar:dbi↦X} = maximal_exists_depth_to depth x φ
depth: nat
dbi: db_index

maximal_exists_depth_to depth x φ^[svar:S dbi↦patt_free_svar X] = maximal_exists_depth_to depth x φ
now rewrite IHφ. Qed. Fixpoint maximal_mu_depth_to (depth : nat) (E : evar) (ψ : Pattern) : nat := match ψ with | patt_bott => 0 | patt_sym _ => 0 | patt_bound_evar _ => 0 | patt_bound_svar _ => 0 | patt_free_svar _ => 0 | patt_free_evar E' => match (decide (E' = E)) with | left _ => depth | right _ => 0 end | patt_imp ψ₁ ψ₂ => Nat.max (maximal_mu_depth_to depth E ψ₁) (maximal_mu_depth_to depth E ψ₂) | patt_app ψ₁ ψ₂ => Nat.max (maximal_mu_depth_to depth E ψ₁) (maximal_mu_depth_to depth E ψ₂) | patt_exists ψ' => maximal_mu_depth_to depth E ψ' | patt_mu ψ' => maximal_mu_depth_to (S depth) E ψ' end.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern

maximal_mu_depth_to depth E ψ^{svar:n↦X} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern

maximal_mu_depth_to depth E ψ^{svar:n↦X} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern

maximal_mu_depth_to depth E ψ^[svar:n↦patt_free_svar X] = maximal_mu_depth_to depth E ψ
Σ: Signature
E: evar
X: svar
ψ: Pattern

(depth : nat) (n : db_index), maximal_mu_depth_to depth E ψ^[svar:n↦patt_free_svar X] = maximal_mu_depth_to depth E ψ
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index

maximal_mu_depth_to depth E match compare_nat n n' with | Nat_less _ _ _ => patt_bound_svar n | Nat_equal _ _ _ => patt_free_svar X | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n) end = 0
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index

maximal_mu_depth_to depth E match compare_nat n n' with | Nat_less _ _ _ => patt_bound_svar n | Nat_equal _ _ _ => patt_free_svar X | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n) end = 0
case_match; simpl; try reflexivity. } Qed.
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern

E ≠ x → maximal_mu_depth_to depth E ψ^{evar:n↦x} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern

E ≠ x → maximal_mu_depth_to depth E ψ^{evar:n↦x} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern
Hne: E ≠ x

maximal_mu_depth_to depth E ψ^{evar:n↦x} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
x: evar
ψ: Pattern
Hne: E ≠ x

maximal_mu_depth_to depth E ψ^[evar:n↦patt_free_evar x] = maximal_mu_depth_to depth E ψ
Σ: Signature
E, x: evar
ψ: Pattern
Hne: E ≠ x

(depth : nat) (n : db_index), maximal_mu_depth_to depth E ψ^[evar:n↦patt_free_evar x] = maximal_mu_depth_to depth E ψ
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index

maximal_mu_depth_to depth E match compare_nat n n' with | Nat_less _ _ _ => patt_bound_evar n | Nat_equal _ _ _ => patt_free_evar x | Nat_greater _ _ _ => patt_bound_evar (Nat.pred n) end = 0
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index

maximal_mu_depth_to depth E match compare_nat n n' with | Nat_less _ _ _ => patt_bound_evar n | Nat_equal _ _ _ => patt_free_evar x | Nat_greater _ _ _ => patt_bound_evar (Nat.pred n) end = 0
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index
e: n = n'
H: compare_nat n n' = Nat_equal n n' e

(if decide (x = E) then depth else 0) = 0
Σ: Signature
E, x: evar
n: db_index
Hne: E ≠ x
depth: nat
n': db_index
e: n = n'
H: compare_nat n n' = Nat_equal n n' e
e0: x = E
H0: decide (x = E) = left e0

depth = 0
Σ: Signature
E: evar
Hne: E ≠ E
depth: nat
n': db_index
H: compare_nat n' n' = Nat_equal n' n' erefl
H0: decide (E = E) = left erefl

depth = 0
contradiction. } Qed.
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern

maximal_mu_depth_to depth E ψ^{svar:n↦X} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern

maximal_mu_depth_to depth E ψ^{svar:n↦X} = maximal_mu_depth_to depth E ψ
Σ: Signature
depth: nat
E: evar
n: db_index
X: svar
ψ: Pattern

maximal_mu_depth_to depth E ψ^[svar:n↦patt_free_svar X] = maximal_mu_depth_to depth E ψ
Σ: Signature
E: evar
X: svar
ψ: Pattern

(depth : nat) (n : db_index), maximal_mu_depth_to depth E ψ^[svar:n↦patt_free_svar X] = maximal_mu_depth_to depth E ψ
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index

maximal_mu_depth_to depth E match compare_nat n n' with | Nat_less _ _ _ => patt_bound_svar n | Nat_equal _ _ _ => patt_free_svar X | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n) end = 0
Σ: Signature
E: evar
X: svar
n: db_index
depth: nat
n': db_index

maximal_mu_depth_to depth E match compare_nat n n' with | Nat_less _ _ _ => patt_bound_svar n | Nat_equal _ _ _ => patt_free_svar X | Nat_greater _ _ _ => patt_bound_svar (Nat.pred n) end = 0
case_match; simpl; try reflexivity. } Qed.
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern

(E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}

(if decide (x = E) then depth else 0) = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}

(if decide (x = E) then depth else 0) = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
e: x = E
H: decide (x = E) = left e

depth = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 0
Σ: Signature
x, E: evar
depth: nat
Hnotin: E ∉ {[x]}
n: x ≠ E
H: decide (x = E) = right n

0 = 0
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` 0 = 0
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` maximal_mu_depth_to depth E ψ2 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

E ∉ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2
0 `max` 0 = 0
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∉ free_evars ψ1 → maximal_mu_depth_to depth E ψ1 = 0
IHψ2: (E : evar) (depth : nat), E ∉ free_evars ψ2 → maximal_mu_depth_to depth E ψ2 = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ1 ∪ free_evars ψ2

0 `max` 0 = 0
reflexivity.
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
maximal_mu_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_mu_depth_to depth E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

0 = 0
reflexivity.
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_mu_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

maximal_mu_depth_to (S depth) E ψ = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

E ∉ free_evars ψ
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ
0 = 0
Σ: Signature
ψ: Pattern
IHψ: (E : evar) (depth : nat), E ∉ free_evars ψ → maximal_mu_depth_to depth E ψ = 0
E: evar
depth: nat
Hnotin: E ∉ free_evars ψ

0 = 0
reflexivity. } Qed.
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∈ free_evars ψ → maximal_mu_depth_to (S depth) E ψ = S (maximal_mu_depth_to depth E ψ)
Σ: Signature
E: evar
ψ: Pattern
depth: nat

E ∈ free_evars ψ → maximal_mu_depth_to (S depth) E ψ = S (maximal_mu_depth_to depth E ψ)
Σ: Signature
E: evar
ψ: Pattern
depth: nat
Hin: E ∈ free_evars ψ

maximal_mu_depth_to (S depth) E ψ = S (maximal_mu_depth_to depth E ψ)
Σ: Signature
ψ: Pattern

(E : evar) (depth : nat), E ∈ free_evars ψ → maximal_mu_depth_to (S depth) E ψ = S (maximal_mu_depth_to depth E ψ)
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}

(if decide (x = E) then S depth else 0) = S (if decide (x = E) then depth else 0)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}

(if decide (x = E) then S depth else 0) = S (if decide (x = E) then depth else 0)
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
e: x = E
H: decide (x = E) = left e

S depth = S depth
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n
0 = 1
Σ: Signature
x, E: evar
depth: nat
Hin: E ∈ {[x]}
n: x ≠ E
H: decide (x = E) = right n

0 = 1
set_solver.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1) `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1) `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ2 = 0

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (0 `max` maximal_mu_depth_to depth E ψ2)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

False
set_solver. }
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1) `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1) `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
e0: E ∈ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
reflexivity.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

E ∈ free_evars ψ1
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: E ∉ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ2 = 0

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
e: E ∈ free_evars ψ1
n: maximal_mu_depth_to depth E ψ2 = 0
n': maximal_mu_depth_to (S depth) E ψ2 = 0

S (maximal_mu_depth_to depth E ψ1) `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` 0)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

E ∈ free_evars ψ2
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: maximal_mu_depth_to depth E ψ1 = 0
e: E ∈ free_evars ψ2
n': maximal_mu_depth_to (S depth) E ψ1 = 0

maximal_mu_depth_to (S depth) E ψ1 `max` S (maximal_mu_depth_to depth E ψ2) = S (0 `max` maximal_mu_depth_to depth E ψ2)
lia.
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

maximal_mu_depth_to (S depth) E ψ1 `max` maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ1 `max` maximal_mu_depth_to depth E ψ2)
Σ: Signature
ψ1, ψ2: Pattern
IHψ1: (E : evar) (depth : nat), E ∈ free_evars ψ1 → maximal_mu_depth_to (S depth) E ψ1 = S (maximal_mu_depth_to depth E ψ1)
IHψ2: (E : evar) (depth : nat), E ∈ free_evars ψ2 → maximal_mu_depth_to (S depth) E ψ2 = S (maximal_mu_depth_to depth E ψ2)
E: evar
depth: nat
Hin: E ∈ free_evars ψ1 ∪ free_evars ψ2
n: E ∉ free_evars ψ1
n0: E ∉ free_evars ψ2

False
set_solver. } } Qed.
Σ: Signature
SvS: SVarSet
n1, n2: nat

list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
Σ: Signature
SvS: SVarSet
n1, n2: nat

list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
Σ: Signature
n1: nat

(SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
Σ: Signature
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq SvS 0) ⊆ list_to_set (svar_fresh_seq SvS (0 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq SvS (S n1)) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
Σ: Signature
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq SvS 0) ⊆ list_to_set (svar_fresh_seq SvS (0 `max` n2))
Σ: Signature
SvS: SVarSet
n2: nat

∅ ⊆ list_to_set (svar_fresh_seq SvS n2)
set_solver.
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq SvS (S n1)) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq SvS (S n1)) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` 0))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` S n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` 0))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ {[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1)
set_solver.
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` S n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq SvS (S n1 `max` S n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

{[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ {[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2)) → {[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ {[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat
list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2)) → {[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ {[svar_fresh_s SvS]} ∪ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))
set_solver.
Σ: Signature
n1: nat
IHn1: (SvS : SVarSet) (n2 : nat), list_to_set (svar_fresh_seq SvS n1) ⊆ list_to_set (svar_fresh_seq SvS (n1 `max` n2))
SvS: SVarSet
n2: nat

list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))
Σ: Signature
n1: nat
SvS: SVarSet
n2: nat
IHn1: list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))

list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) n1) ⊆ list_to_set (svar_fresh_seq ({[svar_fresh_s SvS]} ∪ SvS) (n1 `max` n2))
apply IHn1. } } Qed. (** Note: we cannot reuse NoDup, until the proof system is formalised as `... -> Set`. *) Fixpoint no_dups {A : Set} {eqdec : EqDecision A} (l : list A) := match l with | [] => True | x::xs => x ∉ xs /\ no_dups xs end. Class fresh_evars (l : list evar) (s : EVarSet) := { evar_duplicates : no_dups l; all_evars_fresh : forall x, x ∈ l -> x ∉ s; }.
Σ: Signature
el: list evar
s, s': EVarSet

fresh_evars el s → s' ⊆ s → fresh_evars el s'
Σ: Signature
el: list evar
s, s': EVarSet

fresh_evars el s → s' ⊆ s → fresh_evars el s'
Σ: Signature
el: list evar
s, s': EVarSet
H: fresh_evars el s
H0: s' ⊆ s

fresh_evars el s'
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s

no_dups el
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s
x : evar, x ∈ el → x ∉ s'
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s

x : evar, x ∈ el → x ∉ s'
Σ: Signature
el: list evar
s, s': EVarSet
evar_duplicates0: no_dups el
all_evars_fresh0: x : evar, x ∈ el → x ∉ s
H0: s' ⊆ s
x: evar
H: x ∈ el

x ∉ s'
set_solver. Qed.
Σ: Signature
x: evar
el: list evar
s: EVarSet

fresh_evars (x :: el) s → fresh_evars el s
Σ: Signature
x: evar
el: list evar
s: EVarSet

fresh_evars (x :: el) s → fresh_evars el s
Σ: Signature
x: evar
el: list evar
s: EVarSet
H: fresh_evars (x :: el) s

fresh_evars el s
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s

no_dups el
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s
x : evar, x ∈ el → x ∉ s
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: (x ∉ el) ∧ no_dups el
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s

no_dups el
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s
x : evar, x ∈ el → x ∉ s
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s

x : evar, x ∈ el → x ∉ s
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s
x0: evar
H: x0 ∈ el

x0 ∉ s
Σ: Signature
x: evar
el: list evar
s: EVarSet
evar_duplicates0: no_dups (x :: el)
all_evars_fresh0: x0 : evar, x0 ∈ x :: el → x0 ∉ s
x0: evar
H: x0 ∈ el

x0 ∈ x :: el
now constructor 2. Qed. Class fresh_svars (l : list svar) (s : SVarSet) := { svar_duplicates : no_dups l; all_svars_fresh : forall X, X ∈ l -> X ∉ s; }.
Σ: Signature
sl: list svar
s, s': SVarSet

fresh_svars sl s → s' ⊆ s → fresh_svars sl s'
Σ: Signature
sl: list svar
s, s': SVarSet

fresh_svars sl s → s' ⊆ s → fresh_svars sl s'
Σ: Signature
sl: list svar
s, s': SVarSet
H: fresh_svars sl s
H0: s' ⊆ s

fresh_svars sl s'
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s

no_dups sl
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s
X : svar, X ∈ sl → X ∉ s'
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s

X : svar, X ∈ sl → X ∉ s'
Σ: Signature
sl: list svar
s, s': SVarSet
svar_duplicates0: no_dups sl
all_svars_fresh0: X : svar, X ∈ sl → X ∉ s
H0: s' ⊆ s
X: svar
H: X ∈ sl

X ∉ s'
set_solver. Qed.
Σ: Signature
X: evar
sl: list evar
s: EVarSet

fresh_evars (X :: sl) s → fresh_evars sl s
Σ: Signature
X: evar
sl: list evar
s: EVarSet

fresh_evars (X :: sl) s → fresh_evars sl s
Σ: Signature
X: evar
sl: list evar
s: EVarSet
H: fresh_evars (X :: sl) s

fresh_evars sl s
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s

no_dups sl
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s
x : evar, x ∈ sl → x ∉ s
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: (X ∉ sl) ∧ no_dups sl
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s

no_dups sl
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s
x : evar, x ∈ sl → x ∉ s
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s

x : evar, x ∈ sl → x ∉ s
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s
x: evar
H: x ∈ sl

x ∉ s
Σ: Signature
X: evar
sl: list evar
s: EVarSet
evar_duplicates0: no_dups (X :: sl)
all_evars_fresh0: x : evar, x ∈ X :: sl → x ∉ s
x: evar
H: x ∈ sl

x ∈ X :: sl
now constructor 2. Qed.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
(* TODO: remove the well-formedness constraints on this lemma*)
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

?x ∉ free_evars ψ^[[evar:E↦p]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i exists_quantify ?x ψ^[[evar:E↦p]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i exists_quantify ?x ψ^[[evar:E↦p]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

ProofInfoLe (ExGen := {[?x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦p]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ψ^[[evar:E↦p]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ?B
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦p]]^{evar:0?x} ---> ?B using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦q]]) using BasicReasoning
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar ?y]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦p]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar ?y] using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ψ^[[evar:E↦p]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar ?y] using gpi
apply IH1.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦p]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]]) ^ [patt_free_evar x]
abstract (simpl; wf_auto2; apply wfc_ex_aux_bevar_subst; wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦q]])
abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
abstract ( eapply pile_trans; [|apply pile]; split; simpl; [|split; auto; set_solver]; set_solver ).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars (ex , ψ^[[evar:E↦q]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars (ex , ψ^[[evar:E↦q]])
abstract ( pose proof (Htmp2 := free_evars_free_evar_subst ψ q E); set_solver ). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars ψ^[[evar:E↦p]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars ψ^[[evar:E↦p]]
abstract ( pose proof (Htmp2 := free_evars_free_evar_subst ψ p E); set_solver ).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed_closed_ex_aux ψ^[[evar:E↦p]] 1
wf_auto2. }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]]) using gpi
(* this block is a symmetric version of the previous block*)
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i (ex , ψ^[[evar:E↦q]]) ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

?x ∉ free_evars ψ^[[evar:E↦q]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i exists_quantify ?x ψ^[[evar:E↦q]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i exists_quantify ?x ψ^[[evar:E↦q]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

ProofInfoLe (ExGen := {[?x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
?x ∉ free_evars (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦q]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ψ^[[evar:E↦q]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed ?B
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦q]]^{evar:0?x} ---> ?B using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦p]]) using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ?B ---> (ex , ψ^[[evar:E↦p]]) using BasicReasoning
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0?x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar ?y]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
Γ ⊢i ψ^[[evar:E↦q]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar ?y] using gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

Γ ⊢i ψ^[[evar:E↦q]]^{evar:0?x} ---> (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar ?y] using gpi
apply IH2.
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed ψ^[[evar:E↦q]]^{evar:0↦x}
abstract (wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar x]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]]) ^ [patt_free_evar x]
abstract (simpl; wf_auto2; apply wfc_ex_aux_bevar_subst; wf_auto2).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed (ex , ψ^[[evar:E↦p]])
abstract (wf_auto2). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
x ∉ free_evars (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

ProofInfoLe (ExGen := {[x]}, SVSubst := ∅, KT := false) gpi
abstract ( eapply pile_trans; [|apply pile]; split; simpl; [|split; auto; set_solver]; set_solver ).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars (ex , ψ^[[evar:E↦p]])
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars (ex , ψ^[[evar:E↦p]])
abstract ( pose proof (Htmp2 := free_evars_free_evar_subst ψ p E); set_solver ). }
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars ψ^[[evar:E↦q]]
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi
well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

x ∉ free_evars ψ^[[evar:E↦q]]
abstract ( pose proof (Htmp2 := free_evars_free_evar_subst ψ q E); set_solver ).
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
Σ: Signature
Γ: Theory
E: evar
ψ: Pattern
x: evar
p, q: Pattern
gpi: ProofInfo
kt: bool
evs: coEVarSet
svs: coSVarSet
HxneqE: x ≠ E
wfψ: well_formed (ex , ψ)
wfp: well_formed p
wfq: well_formed q
Heqx: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Heqx2: x ∈ evs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := kt) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} <---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^{evar:0↦x} ---> ψ^[[evar:E↦q]]^{evar:0↦x} using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^{evar:0↦x} ---> ψ^[[evar:E↦p]]^{evar:0↦x} using gpi

well_formed_closed_ex_aux ψ^[[evar:E↦q]] 1
abstract (wf_auto2). } } Defined. End FOL_helpers. Ltac pi_exact H := lazymatch type of H with | ?H' => lazymatch goal with | [|- ?g] => (cut (H' = g); [(let H0 := fresh "H0" in intros H0; rewrite -H0; exact H)| (repeat f_equal; try reflexivity; try apply proof_irrel)]) end end. Ltac pi_assumption := match goal with | [H : _ |- _] => pi_exact H end. Ltac pi_set_solver := set_solver by (try pi_assumption). Section FOL_helpers. Context {Σ : Signature}.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed ?B
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ?B using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ?B <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ?B <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (?B ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ?B)
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ?B ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ?B using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ?B using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
try_solve_pile.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ2^[[evar:E↦q]] ---> ?ϕ₂ using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
abstract (wf_auto2). } }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
try_solve_pile.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦p]] ---> ψ2^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ2^[[evar:E↦q]] ---> ψ2^[[evar:E↦p]])
abstract (wf_auto2). } }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
try_solve_pile.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
abstract (wf_auto2). } }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

ProofInfoLe (ExGen := ∅, SVSubst := ∅, KT := false) i
try_solve_pile.
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

Γ ⊢i ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] using i
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] ---> ψ1^[[evar:E↦p]])
abstract (wf_auto2). } }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]] ---> ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2). }
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2
well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦p]])
abstract (wf_auto2).
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
Σ: Signature
Γ: Theory
ψ1, ψ2, p, q: Pattern
E: evar
i: ProofInfo
wfψ1: well_formed ψ1
wfψ2: well_formed ψ2
wfp: well_formed p
wfq: well_formed q
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using i
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using i
Hwf1: well_formed ψ1^[[evar:E↦p]] = true
HeqHwf1: Hwf1 = well_formed_free_evar_subst_0 E ψ1 p wfp wfψ1
Hwf2: well_formed ψ1^[[evar:E↦q]] = true
HeqHwf2: Hwf2 = well_formed_free_evar_subst_0 E ψ1 q wfq wfψ1
Hwf3: well_formed ψ2^[[evar:E↦p]] = true
HeqHwf3: Hwf3 = well_formed_free_evar_subst_0 E ψ2 p wfp wfψ2
Hwf4: well_formed ψ2^[[evar:E↦q]] = true
HeqHwf4: Hwf4 = well_formed_free_evar_subst_0 E ψ2 q wfq wfψ2

well_formed (ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]])
abstract (wf_auto2). } Defined.
Σ: Signature
φ: Pattern
x, y: evar

x ∉ free_evars φ → count_evar_occurrences x φ^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ
Σ: Signature
φ: Pattern
x, y: evar

x ∉ free_evars φ → count_evar_occurrences x φ^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ
Σ: Signature
x0, x, y: evar
H: x ∉ {[x0]}

count_evar_occurrences x (if decide (y = x0) then patt_free_evar x else patt_free_evar x0) = (if decide (x0 = y) then 1 else 0)
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] + count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] + count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
Σ: Signature
x0, x, y: evar
H: x ∉ {[x0]}

count_evar_occurrences x (if decide (y = x0) then patt_free_evar x else patt_free_evar x0) = (if decide (x0 = y) then 1 else 0)
do 2 destruct decide; simpl; case_match; auto; try contradiction; set_solver.
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2

count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] + count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2

x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 + count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2

x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 + count_evar_occurrences y φ2 = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
all: set_solver.
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2

count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] + count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2

x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 + count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2

x ∉ free_evars φ1
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
x ∉ free_evars φ2
Σ: Signature
φ1, φ2: Pattern
x, y: evar
IHφ1: x ∉ free_evars φ1 → count_evar_occurrences x φ1^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ1
IHφ2: x ∉ free_evars φ2 → count_evar_occurrences x φ2^[[evar:y↦patt_free_evar x]] = count_evar_occurrences y φ2
H: x ∉ free_evars φ1 ∪ free_evars φ2
count_evar_occurrences y φ1 + count_evar_occurrences y φ2 = count_evar_occurrences y φ1 + count_evar_occurrences y φ2
all: set_solver. Qed. Definition mu_in_evar_path E ψ sdepth := negb (Nat.eqb 0 (maximal_mu_depth_to sdepth E ψ)).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
evs: coEVarSet
svs: coSVarSet
wfp: well_formed p
wfq: well_formed q
E: evar
ψ: Pattern
edepth, sdepth: nat
Hsz: size' ψ ≤ sz
wfψ: well_formed ψ
gpi: ProofInfo
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
evs: coEVarSet
svs: coSVarSet
wfp: well_formed p
wfq: well_formed q
E: evar
ψ: Pattern
edepth, sdepth: nat
Hsz: size' ψ ≤ sz
wfψ: well_formed ψ
gpi: ProofInfo
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
(* TODO: if there were a size function for coEVarSet/coSVarSet, then Hel3/Hsl3 would be not necessary *)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar

(edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ 0
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ

Γ ⊢i ψ <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ

Γ ⊢i ψ <---> ψ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ

ProofInfoLe BasicReasoning gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ
well_formed ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ

well_formed ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEnotinψ: E ∉ free_evars ψ

well_formed ψ
abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed ψ
Hsz: size' ψ ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)

Γ ⊢i (if decide (E = x) then p else patt_free_evar x) <---> (if decide (E = x) then q else patt_free_evar x) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_svar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_svar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_svar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_svar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)
Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_evar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_evar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_evar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_evar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)

Γ ⊢i (if decide (E = x) then p else patt_free_evar x) <---> (if decide (E = x) then q else patt_free_evar x) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
e: E = x

Γ ⊢i p <---> q using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x
Γ ⊢i patt_free_evar x <---> patt_free_evar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
e: E = x

Γ ⊢i p <---> q using gpi
exact pf.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x

Γ ⊢i patt_free_evar x <---> patt_free_evar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x

Γ ⊢i patt_free_evar x <---> patt_free_evar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x

Γ ⊢i patt_free_evar x <---> patt_free_evar x using BasicReasoning
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: evar
wfψ: well_formed (patt_free_evar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_evar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_evar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_evar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_evar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_evar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_evar x)
n: E ≠ x

well_formed (patt_free_evar x)
abstract (wf_auto2). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_svar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_svar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_svar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_svar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)

Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_evar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_evar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_evar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_evar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)
Γ ⊢i patt_bound_evar n <---> patt_bound_evar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_svar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_svar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_svar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_svar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)

Γ ⊢i patt_free_svar x <---> patt_free_svar x using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_svar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_svar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_svar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_svar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)

Γ ⊢i patt_free_svar x <---> patt_free_svar x using BasicReasoning
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
x: svar
wfψ: well_formed (patt_free_svar x)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_free_svar x) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_free_svar x) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_free_svar x)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_free_svar x) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_free_svar x)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_free_svar x)

well_formed (patt_free_svar x)
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_evar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_evar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_evar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_evar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)

Γ ⊢i patt_bound_evar n <---> patt_bound_evar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)
Γ ⊢i patt_bound_svar n <---> patt_bound_svar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_evar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_evar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_evar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_evar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)

Γ ⊢i patt_bound_evar n <---> patt_bound_evar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_evar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_evar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_evar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_evar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)

Γ ⊢i patt_bound_evar n <---> patt_bound_evar n using BasicReasoning
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_evar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_evar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_evar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_evar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_evar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_evar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_evar n)

well_formed (patt_bound_evar n)
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)

Γ ⊢i patt_bound_svar n <---> patt_bound_svar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)
Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)

Γ ⊢i patt_bound_svar n <---> patt_bound_svar n using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)

Γ ⊢i patt_bound_svar n <---> patt_bound_svar n using BasicReasoning
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
n: db_index
wfψ: well_formed (patt_bound_svar n)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_bound_svar n) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_bound_svar n) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_bound_svar n)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_bound_svar n) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_bound_svar n)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_bound_svar n)

well_formed (patt_bound_svar n)
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)

Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)

Γ ⊢i patt_sym sigma <---> patt_sym sigma using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)

Γ ⊢i patt_sym sigma <---> patt_sym sigma using BasicReasoning
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
sigma: symbols
wfψ: well_formed (patt_sym sigma)
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (patt_sym sigma) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (patt_sym sigma) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (patt_sym sigma)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (patt_sym sigma) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (patt_sym sigma)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (patt_sym sigma)

well_formed (patt_sym sigma)
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥
Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)

well_formed ψ1 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)

well_formed ψ1 = true
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)

well_formed ψ1 = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz

well_formed ψ2 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz

well_formed ψ2 = true
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)

well_formed ψ2 = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 $ ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 $ ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 $ ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 $ ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 $ ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
length el ≥ maximal_exists_depth_to edepth E ψ1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
length sl ≥ maximal_mu_depth_to sdepth E ψ1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==> pi_uses_kt gpi

pi_uses_kt (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==> pi_uses_kt gpi

mu_in_evar_path E ψ1 sdepth ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat ==> pi_uses_kt gpi

~~ (0 =? maximal_mu_depth_to sdepth E ψ1)%nat ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end ==> pi_uses_kt gpi

~~ match maximal_mu_depth_to sdepth E ψ1 with | 0 => true | S _ => false end ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ1 = S n
H2: S n `max` maximal_mu_depth_to sdepth E ψ2 = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true

pi_uses_kt gpi
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==> pi_uses_kt gpi

pi_uses_kt (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 $ ψ2) sdepth ==> pi_uses_kt gpi

mu_in_evar_path E ψ2 sdepth ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 $ ψ2))%nat ==> pi_uses_kt gpi

~~ (0 =? maximal_mu_depth_to sdepth E ψ2)%nat ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end ==> pi_uses_kt gpi

~~ match maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ2 = S n
H2: maximal_mu_depth_to sdepth E ψ1 `max` S n = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true

pi_uses_kt gpi
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 $ ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 $ ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

Γ ⊢i ψ1^[[evar:E↦p]] $ ψ2^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] $ ψ2^[[evar:E↦q]] using gpi
unshelve (eapply congruence_app); try assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥

Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥

Γ ⊢i ⊥ <---> ⊥ using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥

Γ ⊢i ⊥ <---> ⊥ using BasicReasoning
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
wfψ: well_formed ⊥
Hsz: 1 ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ⊥ sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ⊥ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ⊥
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ⊥ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ⊥
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ⊥

well_formed ⊥
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)

well_formed ψ1 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)

well_formed ψ1 = true
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)

well_formed ψ1 = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz

well_formed ψ2 = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz

well_formed ψ2 = true
Σ: Signature
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)

well_formed ψ2 = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ψ1 ---> ψ2) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ψ1 ---> ψ2)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ψ1 ---> ψ2) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ψ1 ---> ψ2)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ψ1 ---> ψ2)
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==> pi_uses_kt gpi

pi_uses_kt (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ1 sdepth) ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==> pi_uses_kt gpi

mu_in_evar_path E ψ1 sdepth ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat ==> pi_uses_kt gpi

~~ (0 =? maximal_mu_depth_to sdepth E ψ1)%nat ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end ==> pi_uses_kt gpi

~~ match maximal_mu_depth_to sdepth E ψ1 with | 0 => true | S _ => false end ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ1 = S n
H2: S n `max` maximal_mu_depth_to sdepth E ψ2 = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true

pi_uses_kt gpi
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==> pi_uses_kt gpi

pi_uses_kt (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ2 sdepth) ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: mu_in_evar_path E (ψ1 ---> ψ2) sdepth ==> pi_uses_kt gpi

mu_in_evar_path E ψ2 sdepth ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ (0 =? maximal_mu_depth_to sdepth E (ψ1 ---> ψ2))%nat ==> pi_uses_kt gpi

~~ (0 =? maximal_mu_depth_to sdepth E ψ2)%nat ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: ~~ match maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end ==> pi_uses_kt gpi

~~ match maximal_mu_depth_to sdepth E ψ2 with | 0 => true | S _ => false end ==> pi_uses_kt gpi
Σ: Signature
E: evar
sdepth: nat
ψ1, ψ2: Pattern
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
n: nat
H3: maximal_mu_depth_to sdepth E ψ2 = S n
H2: maximal_mu_depth_to sdepth E ψ1 `max` S n = 0
i':= ExGen := evs, SVSubst := svs, KT := false: ProofInfo
H: evs ⊆ pi_generalized_evars gpi
H0: svs ⊆ pi_substituted_svars gpi
H1: true

pi_uses_kt gpi
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

Γ ⊢i (ψ1^[[evar:E↦p]] ---> ψ2^[[evar:E↦p]]) <---> (ψ1^[[evar:E↦q]] ---> ψ2^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ1^[[evar:E↦p]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
well_formed ψ2^[[evar:E↦p]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
well_formed ψ1^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ1^[[evar:E↦p]] = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ2^[[evar:E↦p]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
well_formed ψ1^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ2^[[evar:E↦p]] = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ1^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ1^[[evar:E↦q]] = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ2^[[evar:E↦q]] = true
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

well_formed ψ2^[[evar:E↦q]] = true
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
apply pf₁.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ1, ψ2: Pattern
wfψ: well_formed (ψ1 ---> ψ2)
Hsz: S (size' ψ1 + size' ψ2) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ψ1 ---> ψ2) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ1 ∪ free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ1 `max` maximal_exists_depth_to edepth E ψ2
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ1 ∪ free_svars ψ2 ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ1 `max` maximal_mu_depth_to sdepth E ψ2
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ1 ∪ free_evars ψ2
wfψ1: well_formed ψ1 = true
H: size' ψ1 ≤ sz
wfψ2: well_formed ψ2 = true
H0: size' ψ2 ≤ sz
Hef1: fresh_evars el (free_evars ψ1 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf1: fresh_svars sl (free_svars ψ1 ∪ free_svars p ∪ free_svars q)
pf₁: Γ ⊢i ψ1^[[evar:E↦p]] <---> ψ1^[[evar:E↦q]] using gpi
Hef2: fresh_evars el (free_evars ψ2 ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hsf2: fresh_svars sl (free_svars ψ2 ∪ free_svars p ∪ free_svars q)
pf₂: Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi

Γ ⊢i ψ2^[[evar:E↦p]] <---> ψ2^[[evar:E↦q]] using gpi
apply pf₂. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (ex , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (ex , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (ex , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (ex , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (ex , ψ)

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars [] (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length [] ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars [] (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length [] ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars [] (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: 0 ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars [] (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars [] (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Hel2: 0 ≥ S (maximal_exists_depth_to edepth E ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
Hel1: fresh_evars [] (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x : evar, x ∈ [] → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
Hel2: 0 ≥ S (maximal_exists_depth_to edepth E ψ)

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

no_dups els
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
x0 : evar, x0 ∈ els → x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

no_dups els
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

no_dups els
apply evar_duplicates0.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

x0 : evar, x0 ∈ els → x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz

x0 : evar, x0 ∈ els → x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
x0: evar
H1: x0 ∈ els

x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
x0: evar
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ

x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: no_dups (x :: els)
x0: evar
all_evars_fresh0: x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ

x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
evar_duplicates0: (x ∉ els) ∧ no_dups els
x0: evar
all_evars_fresh0: x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: S (length els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ

x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
H3: x ∉ els
H4: no_dups els
x0: evar
all_evars_fresh0: x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel2: S (length els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
H1: x0 ∈ els
H2: free_evars ψ^{evar:0↦x} ⊆ {[x]} ∪ free_evars ψ

x0 ∉ free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]}
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length (x :: els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ maximal_exists_depth_to (S edepth) E ψ
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})

E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)

E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)

E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)

E ≠ x
Σ: Signature
p, q: Pattern
E: evar
ψ: Pattern
x: evar
els: list evar
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}

E ≠ x
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

ProofInfoLe (ExGen := evs ∪ {[x]}, SVSubst := svs, KT := mu_in_evar_path E ψ^{evar:0↦x} sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els ≥ maximal_exists_depth_to edepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

ProofInfoLe (ExGen := evs ∪ {[x]}, SVSubst := svs, KT := mu_in_evar_path E ψ^{evar:0↦x} sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

ProofInfoLe (ExGen := evs ∪ {[x]}, SVSubst := svs, KT := mu_in_evar_path E ψ^{evar:0↦x} sdepth) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E ψ)%nat) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E (ex , ψ))%nat: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

ProofInfoLe (ExGen := evs ∪ {[x]}, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E ψ^{evar:0↦x})%nat) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

ProofInfoLe (ExGen := evs ∪ {[x]}, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ^{evar:0↦x} with | 0 => true | S _ => false end) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
ProofInfoLe (ExGen := evs ∪ {[x]}, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

E ≠ x
auto.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

length els ≥ maximal_exists_depth_to edepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

length els ≥ maximal_exists_depth_to edepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
length els ≥ maximal_exists_depth_to edepth E ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x

length els ≥ maximal_exists_depth_to edepth E ψ
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
X : svar, X ∈ sl → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q)
now rewrite free_svars_evar_open.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
X : svar, X ∈ sl → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

E ≠ x
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
length sl ≥ maximal_mu_depth_to sdepth E ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

length sl ≥ maximal_mu_depth_to sdepth E ψ
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

X : svar, X ∈ sl → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: fresh_svars sl (free_svars ψ^{evar:0↦x} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{evar:0↦x} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

X : svar, X ∈ sl → X ∈ svs
assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

Γ ⊢i (ex , ψ^[[evar:E↦p]]) <---> (ex , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ≠ E
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := ?evs, SVSubst := ?svs, KT := ?kt) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ≠ E
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ≠ E
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ≠ E
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := ?evs, SVSubst := ?svs, KT := ?kt) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x0 : evar, x0 ∈ x :: els → x0 ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
all_evars_fresh0: x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∉ free_evars ψ ∪ free_evars p ∪ free_evars q
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi
ProofInfoLe (ExGen := ?evs, SVSubst := ?svs, KT := ?kt) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∈ ?evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

x ∈ x :: els
now left.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt) i'
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (ex , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
x: evar
els: list evar
Hel1: fresh_evars (x :: els) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel3: x0 : evar, x0 ∈ x :: els → x0 ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E ψ
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{evar:0↦x}
H0: size' ψ^{evar:0↦x} ≤ sz
HVars: fresh_evars els (free_evars ψ^{evar:0↦x} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: S (length els) ≥ S (maximal_exists_depth_to edepth E ψ)
HXe: E ≠ x
IH: Γ ⊢i ψ^{evar:0↦x}^[[evar:E↦p]] <---> ψ^{evar:0↦x}^[[evar:E↦q]] using gpi

ProofInfoLe (ExGen := evs, SVSubst := ?svs, KT := ?kt) (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (ex , ψ) sdepth)
now apply pile_refl. }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
sl: list svar
Hsl1: fresh_svars sl (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length sl ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ sl → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars [] (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length [] ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length (X :: sls) ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars [] (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length [] ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars [] (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: 0 ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars [] (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl3: X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars [] (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl3: X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Hsl2: 0 ≥ S (maximal_mu_depth_to sdepth E ψ)
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
Hsl1: fresh_svars [] (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl3: X : svar, X ∈ [] → X ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
Hsl2: 0 ≥ S (maximal_mu_depth_to sdepth E ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length (X :: sls) ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length (X :: sls) ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
H: well_formed ψ^{svar:0↦X} = true

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars (mu , ψ) ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E (mu , ψ)
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars (mu , ψ) ∪ free_svars p ∪ free_svars q)
Hsl2: length (X :: sls) ≥ maximal_mu_depth_to sdepth E (mu , ψ)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars (mu , ψ)
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
i':= ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth: ProofInfo
pile: ProofInfoLe i' gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E ψ sdepth) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := mu_in_evar_path E (mu , ψ) sdepth) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E ψ)%nat) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ (0 =? maximal_mu_depth_to sdepth E (mu , ψ))%nat) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to (S sdepth) E ψ with | 0 => true | S _ => false end) gpi
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz

E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ^{svar:0↦X} with | 0 => true | S _ => false end) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ^{svar:0↦X} with | 0 => true | S _ => false end) gpi
try_solve_pile.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
x : evar, x ∈ el → x ∈ evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]})
now rewrite free_evars_svar_open.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
x : evar, x ∈ el → x ∈ evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

length el ≥ maximal_exists_depth_to edepth E ψ
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

x : evar, x ∈ el → x ∈ evs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_evars el (free_evars ψ^{svar:0↦X} ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ^{svar:0↦X} → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

x : evar, x ∈ el → x ∈ evs
assumption.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: sl : list svar, fresh_svars sl (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

no_dups sls
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0 : svar, X0 ∈ sls → X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

no_dups sls
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

no_dups sls
apply svar_duplicates0.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

X0 : svar, X0 ∈ sls → X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

X0 : svar, X0 ∈ sls → X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls

X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ

X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: no_dups (X :: sls)
X0: svar
all_svars_fresh0: X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ

X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
svar_duplicates0: (X ∉ sls) ∧ no_dups sls
X0: svar
all_svars_fresh0: X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := true) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ

X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
H3: X ∉ sls
H4: no_dups sls
X0: svar
all_svars_fresh0: X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := true) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ

X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
Σ: Signature
p, q, ψ: Pattern
X: svar
sls: list svar
H3: X ∉ sls
X0: svar
all_svars_fresh0: X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
H1: X0 ∈ sls
H2: free_svars ψ^{svar:0↦X} ⊆ {[X]} ∪ free_svars ψ

X0 ∉ free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X}
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

length sls ≥ maximal_mu_depth_to sdepth E ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

E ∈ free_evars ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Hsl2: S (length sls) ≥ S (maximal_mu_depth_to sdepth E ψ)
length sls ≥ maximal_mu_depth_to sdepth E ψ
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Hsl2: S (length sls) ≥ S (maximal_mu_depth_to sdepth E ψ)

length sls ≥ maximal_mu_depth_to sdepth E ψ
lia.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

X : svar, X ∈ sls → X ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls

X0 ∈ svs
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: fresh_svars sls (free_svars ψ^{svar:0↦X} ∪ free_svars p ∪ free_svars q) → length sls ≥ maximal_mu_depth_to sdepth E ψ^{svar:0↦X} → ( X : svar, X ∈ sls → X ∈ svs) → Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi
X0: svar
H1: X0 ∈ sls

X0 ∈ X :: sls
now right.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^{svar:0↦X}^[[evar:E↦p]] <---> ψ^{svar:0↦X}^[[evar:E↦q]] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[svar:0↦patt_free_svar X]^[[evar:E↦p]] <---> ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

well_formed_closed_mu_aux p 0
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

E ∉ free_evars (patt_free_svar X)
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[svar:0↦patt_free_svar X]^[[evar:E↦q]] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

well_formed_closed_mu_aux q 0
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

evar_is_fresh_in E (patt_free_svar X)
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi

E ∉ free_evars (patt_free_svar X)
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar

well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar

well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar

well_formed ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X]
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi

well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar

well_formed ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X]
abstract (wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <---> (mu , ψ^[[evar:E↦q]]) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦q]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦q]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦q]] ⊆ free_svars ψ ∪ free_svars q

X ∉ free_svars ψ^[[evar:E↦q]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦q]] ⊆ free_svars ψ ∪ free_svars q

X ∉ free_svars ψ^[[evar:E↦q]]
Σ: Signature
p, q: Pattern
E: evar
ψ: Pattern
X: svar
sls: list svar
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
H1: free_svars ψ^[[evar:E↦q]] ⊆ free_svars ψ ∪ free_svars q

X ∉ free_svars ψ^[[evar:E↦q]]
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦q]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦p]] ⊆ free_svars ψ ∪ free_svars p

X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
H1: free_svars ψ^[[evar:E↦p]] ⊆ free_svars ψ ∪ free_svars p

X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
p, q: Pattern
E: evar
ψ: Pattern
X: svar
sls: list svar
all_svars_fresh0: X0 : svar, X0 ∈ X :: sls → X0 ∉ free_svars ψ ∪ free_svars p ∪ free_svars q
H1: free_svars ψ^[[evar:E↦p]] ⊆ free_svars ψ ∪ free_svars p

X ∉ free_svars ψ^[[evar:E↦p]]
set_solver.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦q]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed_closed_mu_aux ψ^[[evar:E↦p]] 1
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) <---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) ---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) ---> (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) ---> (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i ψ^[[evar:E↦q]]^{svar:0↦X} ---> ψ^[[evar:E↦p]]^{svar:0↦X} using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i ψ^[[evar:E↦q]]^{svar:0↦X} ---> ψ^[[evar:E↦p]]^{svar:0↦X} using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] using gpi
apply IH2.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
abstract (try_solve_pile). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) ---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}}) ---> (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}}) using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
Γ ⊢i ψ^[[evar:E↦p]]^{svar:0↦X} ---> ψ^[[evar:E↦q]]^{svar:0↦X} using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i ψ^[[evar:E↦p]]^{svar:0↦X} ---> ψ^[[evar:E↦q]]^{svar:0↦X} using gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦patt_free_svar X] using gpi
apply IH1.
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦p]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
svar_has_negative_occurrence X ψ^[[evar:E↦q]]^{svar:0↦X} = false
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

ProofInfoLe (ExGen := ∅, SVSubst := {[X]}, KT := true) gpi
abstract (try_solve_pile). }
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦p]] → well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦p]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦p]] → well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar

X ∉ free_svars ψ^[[evar:E↦p]] → well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
p: Pattern
wfp: well_formed p
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
H: X ∉ free_svars ψ^[[evar:E↦p]]

well_formed (mu , ψ^[[evar:E↦p]]^{svar:0↦X}^{{svar:X↦0}})
(* TODO: this rewrite somewhy does not happen in wf_auto2 *) abstract (rewrite svar_quantify_svar_open;wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦p]]
abstract ( pose proof (Htmp := free_svars_free_evar_subst ψ E p); destruct Hsl1 as [_ Hsl1]; specialize (Hsl1 X ltac:(now left)); clear -H Htmp ψ Hsl1; set_solver ).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦q]] → well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi
X ∉ free_svars ψ^[[evar:E↦q]]
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦q]] → well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar

X ∉ free_svars ψ^[[evar:E↦q]] → well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
Σ: Signature
q: Pattern
wfq: well_formed q
E: evar
ψ: Pattern
wfψ: well_formed (mu , ψ)
X: svar
H: X ∉ free_svars ψ^[[evar:E↦q]]

well_formed (mu , ψ^[[evar:E↦q]]^{svar:0↦X}^{{svar:X↦0}})
abstract (rewrite svar_quantify_svar_open; wf_auto2).
Σ: Signature
sz: nat
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
E: evar
IHsz: (edepth sdepth : nat) (ψ : Pattern), well_formed ψ → size' ψ ≤ sz → (evs : coEVarSet) (svs : coSVarSet) (gpi : ProofInfo), ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ match maximal_mu_depth_to sdepth E ψ with | 0 => true | S _ => false end) gpi → Γ ⊢i p <---> q using gpi → el : list evar, fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) → length el ≥ maximal_exists_depth_to edepth E ψ → ( x : evar, x ∈ el → x ∈ evs) → sl : list svar, fresh_svars sl (free_svars ψ ∪ free_svars p ∪ free_svars q) → length sl ≥ maximal_mu_depth_to sdepth E ψ → ( X : svar, X ∈ sl → X ∈ svs) → Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
edepth, sdepth: nat
ψ: Pattern
wfψ: well_formed (mu , ψ)
Hsz: S (size' ψ) ≤ S sz
evs: coEVarSet
svs: coSVarSet
gpi: ProofInfo
pf: Γ ⊢i p <---> q using gpi
el: list evar
Hel1: fresh_evars el (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Hel2: length el ≥ maximal_exists_depth_to edepth E ψ
Hel3: x : evar, x ∈ el → x ∈ evs
X: svar
sls: list svar
Hsl1: fresh_svars (X :: sls) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Hsl2: S (length sls) ≥ maximal_mu_depth_to (S sdepth) E ψ
Hsl3: X0 : svar, X0 ∈ X :: sls → X0 ∈ svs
HEinψ: E ∈ free_evars ψ
H: well_formed ψ^{svar:0↦X} = true
H0: size' ψ^{svar:0↦X} ≤ sz
pile: ProofInfoLe (ExGen := evs, SVSubst := svs, KT := ~~ false) gpi
IH: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] <---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH1: Γ ⊢i ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] using gpi
IH2: Γ ⊢i ψ^[[evar:E↦q]]^[svar:0↦ patt_free_svar X] ---> ψ^[[evar:E↦p]]^[svar:0↦ patt_free_svar X] using gpi

X ∉ free_svars ψ^[[evar:E↦q]]
abstract ( pose proof (Htmp := free_svars_free_evar_subst ψ E q); destruct Hsl1 as [_ Hsl1]; specialize (Hsl1 X ltac:(now left)); clear -H Htmp ψ Hsl1; set_solver ). } } Defined. (* Correctness of evar_fresh_seq *)
Σ: Signature
n: nat
s: EVarSet

fresh_evars (evar_fresh_seq s n) s
Σ: Signature
n: nat
s: EVarSet

fresh_evars (evar_fresh_seq s n) s
Σ: Signature
n: nat

s : EVarSet, fresh_evars (evar_fresh_seq s n) s
Σ: Signature
s: EVarSet

fresh_evars [] s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
fresh_evars (evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) s
Σ: Signature
s: EVarSet

fresh_evars [] s
Σ: Signature
s: EVarSet

True
Σ: Signature
s: EVarSet
x : evar, x ∈ [] → x ∉ s
Σ: Signature
s: EVarSet

x : evar, x ∈ [] → x ∉ s
Σ: Signature
s: EVarSet
x: evar
H: x ∈ []

x ∉ s
set_solver.
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet

fresh_evars (evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

fresh_evars (evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

no_dups (evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x : evar, x ∈ evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

no_dups (evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

(evar_fresh_s s ∉ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) ∧ no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

evar_fresh_s s ∉ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
H: list_to_set (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n) ## {[evar_fresh_s s]} ∪ s

evar_fresh_s s ∉ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
set_solver.
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

x : evar, x ∈ evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∈ evar_fresh_s s :: evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n

x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x = evar_fresh_s s

x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n
x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x = evar_fresh_s s

x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

evar_fresh_s s ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s

evar_fresh (elements s) ∉ s
apply set_evar_fresh_is_fresh'.
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n

x ∉ s
Σ: Signature
n: nat
IHn: s : EVarSet, fresh_evars (evar_fresh_seq s n) s
s: EVarSet
Dups: no_dups (evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n)
Fresh: x : evar, x ∈ evar_fresh_seq ({[evar_fresh_s s]} ∪ s) n → x ∉ {[evar_fresh_s s]} ∪ s
x: evar
H: x ∉ {[evar_fresh_s s]} ∪ s

x ∉ s
set_solver. Qed. (* Correctness of svar_fresh_seq *)
Σ: Signature
n: nat
s: SVarSet

fresh_svars (svar_fresh_seq s n) s
Σ: Signature
n: nat
s: SVarSet

fresh_svars (svar_fresh_seq s n) s
Σ: Signature
n: nat

s : SVarSet, fresh_svars (svar_fresh_seq s n) s
Σ: Signature
s: SVarSet

fresh_svars [] s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
fresh_svars (svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) s
Σ: Signature
s: SVarSet

fresh_svars [] s
Σ: Signature
s: SVarSet

True
Σ: Signature
s: SVarSet
X : svar, X ∈ [] → X ∉ s
Σ: Signature
s: SVarSet

X : svar, X ∈ [] → X ∉ s
Σ: Signature
s: SVarSet
X: svar
H: X ∈ []

X ∉ s
set_solver.
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet

fresh_svars (svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

fresh_svars (svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

no_dups (svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X : svar, X ∈ svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

no_dups (svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

(svar_fresh_s s ∉ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) ∧ no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

svar_fresh_s s ∉ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
H: list_to_set (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n) ## {[svar_fresh_s s]} ∪ s

svar_fresh_s s ∉ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
set_solver.
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

X : svar, X ∈ svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∈ svar_fresh_s s :: svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n

X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X = svar_fresh_s s

X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n
X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X = svar_fresh_s s

X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

svar_fresh_s s ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s

svar_fresh (elements s) ∉ s
apply set_svar_fresh_is_fresh'.
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n

X ∉ s
Σ: Signature
n: nat
IHn: s : SVarSet, fresh_svars (svar_fresh_seq s n) s
s: SVarSet
Dups: no_dups (svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n)
Fresh: X : svar, X ∈ svar_fresh_seq ({[svar_fresh_s s]} ∪ s) n → X ∉ {[svar_fresh_s s]} ∪ s
X: svar
H: X ∉ {[svar_fresh_s s]} ∪ s

X ∉ s
set_solver. Qed.
Σ: Signature
l: EVarSet
n: nat

length (evar_fresh_seq l n) = n
Σ: Signature
l: EVarSet
n: nat

length (evar_fresh_seq l n) = n
Σ: Signature
n: nat

l : EVarSet, length (evar_fresh_seq l n) = n
induction n; intro l; simpl; auto. Qed.
Σ: Signature
l: SVarSet
n: nat

length (svar_fresh_seq l n) = n
Σ: Signature
l: SVarSet
n: nat

length (svar_fresh_seq l n) = n
Σ: Signature
n: nat

l : SVarSet, length (svar_fresh_seq l n) = n
induction n; intro l; simpl; auto. Qed.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

Γ ⊢i p <---> q using gpi → Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

Γ ⊢i p <---> q using gpi → Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi

Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi

well_formed (p <---> q)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi

well_formed (p <---> q)
abstract ( pose proof (proved_impl_wf _ _ (proj1_sig Hiff)); assumption ).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)

Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p

Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf C
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern {| pcEvar := E; pcPattern := ψ |}) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar {| pcEvar := E; pcPattern := ψ |}]}) (maximal_exists_depth_to 0 (pcEvar {| pcEvar := E; pcPattern := ψ |}) (pcPattern {| pcEvar := E; pcPattern := ψ |}))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern {| pcEvar := E; pcPattern := ψ |}) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar {| pcEvar := E; pcPattern := ψ |}) (pcPattern {| pcEvar := E; pcPattern := ψ |}))), KT := mu_in_evar_path (pcEvar {| pcEvar := E; pcPattern := ψ |}) (pcPattern {| pcEvar := E; pcPattern := ψ |}) 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

Γ ⊢i ({| pcEvar := E; pcPattern := ψ |} [p]) <---> ({| pcEvar := E; pcPattern := ψ |} [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

Γ ⊢i ({| pcEvar := E; pcPattern := ψ |} [p]) <---> ({| pcEvar := E; pcPattern := ψ |} [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

Γ ⊢i (pcPattern {| pcEvar := E; pcPattern := ψ |})^[[evar: pcEvar {| pcEvar := E; pcPattern := ψ |}↦p]] <---> (pcPattern {| pcEvar := E; pcPattern := ψ |})^[[evar: pcEvar {| pcEvar := E; pcPattern := ψ |}↦q]] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

Γ ⊢i ψ^[[evar:E↦p]] <---> ψ^[[evar:E↦q]] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

size' ψ ≤ ?sz
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_evars (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) ≥ maximal_exists_depth_to ?edepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
x : evar, x ∈ evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ) → x ∈ list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ ?sdepth) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

size' ψ ≤ ?sz
apply reflexivity.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

fresh_evars (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) ≥ maximal_exists_depth_to ?edepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
x : evar, x ∈ evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ) → x ∈ list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ ?sdepth) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

fresh_evars (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]})
abstract (apply evar_fresh_seq_correct).
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

length (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) ≥ maximal_exists_depth_to ?edepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
x : evar, x ∈ evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ) → x ∈ list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ ?sdepth) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

length (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)) ≥ maximal_exists_depth_to ?edepth E ψ
instantiate (1 := 0); abstract (pose proof (evar_fresh_seq_length (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)); lia).
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

x : evar, x ∈ evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ) → x ∈ list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
fresh_svars (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ ?sdepth) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

x : evar, x ∈ evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ) → x ∈ list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
x: evar
H2: x ∈ evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)

x ∈ list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ))
set_solver.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

fresh_svars (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) (free_svars ψ ∪ free_svars p ∪ free_svars q)
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ ?sdepth) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

fresh_svars (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) (free_svars ψ ∪ free_svars p ∪ free_svars q)
abstract (apply svar_fresh_seq_correct).
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ ?sdepth) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

length (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)) ≥ maximal_mu_depth_to ?sdepth E ψ
instantiate (1 := 0); abstract (pose proof (svar_fresh_seq_length (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)); lia).
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

X : svar, X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ) → X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q
X: svar
H2: X ∈ svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)

X ∈ list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ))
set_solver.
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
E: evar
ψ: Pattern
gpi: ProofInfo
wfp: well_formed p = true
wfq: well_formed q = true
wfC: PC_wf {| pcEvar := E; pcPattern := ψ |}
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
Hiff: Γ ⊢i p <---> q using gpi
H: well_formed (p <---> q)
H0: well_formed p
H1: well_formed q

ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars ψ ∪ free_evars p ∪ free_evars q ∪ {[E]}) (maximal_exists_depth_to 0 E ψ)), SVSubst := list_to_set (svar_fresh_seq (free_svars ψ ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 E ψ)), KT := mu_in_evar_path E ψ 0) gpi
try_solve_pile. } Defined. End FOL_helpers.
Σ: Signature
φ, ψ: Pattern
x, y: evar

y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Σ: Signature
φ, ψ: Pattern
x, y: evar

y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}

(if decide (x = x0) then patt_free_evar y else patt_free_evar x0)^[[evar:y↦ψ]] = (if decide (x = x0) then ψ else patt_free_evar x0)
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] $ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] ---> φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(ex , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (ex , φ^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(mu , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (mu , φ^[[evar:x↦ψ]])
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}

(if decide (x = x0) then patt_free_evar y else patt_free_evar x0)^[[evar:y↦ψ]] = (if decide (x = x0) then ψ else patt_free_evar x0)
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
e: x = x0
H: decide (x = x0) = left e
n: y ≠ y
H0: decide (y = y) = right n

patt_free_evar y = ψ
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
n: x ≠ x0
H: decide (x = x0) = right n
e: y = x0
H0: decide (y = x0) = left e
ψ = patt_free_evar x0
Σ: Signature
x0: evar
ψ: Pattern
x, y: evar
Hin: y ∉ {[x0]}
n: x ≠ x0
H: decide (x = x0) = right n
e: y = x0
H0: decide (y = x0) = left e

ψ = patt_free_evar x0
set_solver.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] $ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

y ∉ free_evars φ1
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

y ∉ free_evars φ2
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] = φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]] = φ1^[[evar:x↦ψ]] $ φ2^[[evar:x↦ψ]]
reflexivity.
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

(φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] ---> φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

y ∉ free_evars φ1
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

y ∉ free_evars φ2
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2
(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) = (φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
Σ: Signature
φ1, φ2, ψ: Pattern
x, y: evar
IHφ1: y ∉ free_evars φ1 → φ1^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ1^[[evar:x↦ψ]]
IHφ2: y ∉ free_evars φ2 → φ2^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ2^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ1 ∪ free_evars φ2

(φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]]) = (φ1^[[evar:x↦ψ]] ---> φ2^[[evar:x↦ψ]])
reflexivity.
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ

(ex , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (ex , φ^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ

y ∉ free_evars φ
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(ex , φ^[[evar:x↦ψ]]) = (ex , φ^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ

(ex , φ^[[evar:x↦ψ]]) = (ex , φ^[[evar:x↦ψ]])
reflexivity.
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ

(mu , φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]]) = (mu , φ^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ

y ∉ free_evars φ
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ
(mu , φ^[[evar:x↦ψ]]) = (mu , φ^[[evar:x↦ψ]])
Σ: Signature
φ, ψ: Pattern
x, y: evar
IHφ: y ∉ free_evars φ → φ^[[evar:x↦patt_free_evar y]]^[[evar:y↦ψ]] = φ^[[evar:x↦ψ]]
Hin: y ∉ free_evars φ

(mu , φ^[[evar:x↦ψ]]) = (mu , φ^[[evar:x↦ψ]])
reflexivity. Qed. Definition free_evars_of_list {Σ : Signature} l := foldr (λ x0 acc, free_evars x0 ∪ acc) ∅ l.
Σ: Signature
l: list Pattern
C: PatternCtx
p: Pattern

pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
Σ: Signature
l: list Pattern
C: PatternCtx
p: Pattern

pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
Σ: Signature
l: list Pattern

(C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
Σ: Signature
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list []

(C [p]) = (pcPattern C)^[[evar:pcEvar C↦p]]
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)
(a ---> foldr patt_imp (C [p]) l) = (a^[[evar:pcEvar C↦p]] ---> (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
Σ: Signature
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list []

(C [p]) = (pcPattern C)^[[evar:pcEvar C↦p]]
auto.
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)

(a ---> foldr patt_imp (C [p]) l) = (a^[[evar:pcEvar C↦p]] ---> (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars_of_list (a :: l)

(a ---> foldr patt_imp (C [p]) l) = (a^[[evar:pcEvar C↦p]] ---> (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

(a ---> foldr patt_imp (C [p]) l) = (a^[[evar:pcEvar C↦p]] ---> (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

pcEvar C ∉ free_evars a
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l
(a ---> foldr patt_imp (C [p]) l) = (a ---> (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

pcEvar C ∉ free_evars a
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

pcEvar C ∉ free_evars a
set_solver.
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

(a ---> foldr patt_imp (C [p]) l) = (a ---> (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]])
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

foldr patt_imp (C [p]) l = (foldr patt_imp (pcPattern C) l)^[[evar:pcEvar C↦p]]
Σ: Signature
a: Pattern
l: list Pattern
IHl: (C : PatternCtx) (p : Pattern), pcEvar C ∉ free_evars_of_list l → foldr patt_imp (C [p]) l = ({| pcEvar := pcEvar C; pcPattern := foldr patt_imp (pcPattern C) l |} [p])
C: PatternCtx
p: Pattern
Hin: pcEvar C ∉ free_evars a ∪ free_evars_of_list l

pcEvar C ∉ free_evars_of_list l
set_solver. } Qed. (** NOTE: the following lemmas are very specific for prf_equiv_congruence_iter *)
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat

x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat

x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ ∅

maximal_exists_depth_to edepth x ψ = maximal_exists_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
maximal_exists_depth_to edepth x a `max` maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ ∅

maximal_exists_depth_to edepth x ψ = maximal_exists_depth_to edepth x ψ
reflexivity.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l

maximal_exists_depth_to edepth x a `max` maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a

maximal_exists_depth_to edepth x a `max` maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a
HIND: x ∉ free_evars_of_list l

maximal_exists_depth_to edepth x a `max` maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a
HIND: maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ

maximal_exists_depth_to edepth x a `max` maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a
HIND: maximal_exists_depth_to edepth x (foldr patt_imp ψ l) = maximal_exists_depth_to edepth x ψ

maximal_exists_depth_to edepth x a `max` maximal_exists_depth_to edepth x ψ = maximal_exists_depth_to edepth x ψ
rewrite maximal_exists_depth_to_0; auto. Qed.
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat

x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
l: list Pattern
ψ: Pattern
x: evar
edepth: nat

x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ ∅

maximal_mu_depth_to edepth x ψ = maximal_mu_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
maximal_mu_depth_to edepth x a `max` maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
ψ: Pattern
x: evar
edepth: nat
Hin: x ∉ ∅

maximal_mu_depth_to edepth x ψ = maximal_mu_depth_to edepth x ψ
reflexivity.
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l

maximal_mu_depth_to edepth x a `max` maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a

maximal_mu_depth_to edepth x a `max` maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a
HIND: x ∉ foldr (λ (x : Pattern) (acc : EVarSet), free_evars x ∪ acc) ∅ l

maximal_mu_depth_to edepth x a `max` maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a
HIND: maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ

maximal_mu_depth_to edepth x a `max` maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Σ: Signature
a: Pattern
l: list Pattern
ψ: Pattern
x: evar
edepth: nat
IHl: x ∉ free_evars_of_list l → maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ
Hin: x ∉ free_evars a ∪ free_evars_of_list l
Ha: x ∉ free_evars a
HIND: maximal_mu_depth_to edepth x (foldr patt_imp ψ l) = maximal_mu_depth_to edepth x ψ

maximal_mu_depth_to edepth x a `max` maximal_mu_depth_to edepth x ψ = maximal_mu_depth_to edepth x ψ
rewrite maximal_mu_depth_to_0; auto. Qed. (* NOTE: This version of the iterated congruence lemma is proved by induction. There is a way, to prove this lemma without induction (see `TEST_proofmode_proof_size.v`), but the generated proof term becomes much more larger (2-3 times larger than the induction-based). This is because the proof of the congruence lemma is more complex for bigger contexts. *)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

wf l → Γ ⊢i p <---> q using gpi → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

wf l → Γ ⊢i p <---> q using gpi → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: wf l
Himp: Γ ⊢i p <---> q using gpi

Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: wf []
Himp: Γ ⊢i p <---> q using gpi

Γ ⊢i (C [p]) <---> (C [q]) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: wf (a :: l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: wf []
Himp: Γ ⊢i p <---> q using gpi

Γ ⊢i (C [p]) <---> (C [q]) using gpi
unshelve(eapply prf_equiv_congruence); assumption.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: wf (a :: l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: wf (a :: l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: foldr andb true (map well_formed (a :: l))
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfl: well_formed a && foldr andb true (map well_formed l)
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: wf l → Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)

well_formed (C [p])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)

well_formed (C [p])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)

well_formed (pcPattern C)^[[evar:pcEvar C↦p]]
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])

well_formed (C [q])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])

well_formed (C [q])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])

well_formed (pcPattern C)^[[evar:pcEvar C↦q]]
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ ⊢i (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed ((a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed ((a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed ((a ---> foldr patt_imp (pcPattern C)^[[evar:pcEvar C↦p]] l) <---> (a ---> foldr patt_imp (pcPattern C)^[[evar:pcEvar C↦q]] l))
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ (a ---> foldr patt_imp (C [p]) l) <---> (a ---> foldr patt_imp (C [q]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ ((a ---> foldr patt_imp (C [p]) l) ---> a ---> foldr patt_imp (C [q]) l) and ((a ---> foldr patt_imp (C [q]) l) ---> a ---> foldr patt_imp (C [p]) l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ (a ---> foldr patt_imp (C [p]) l) ---> a ---> foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Γ Ⱶ (a ---> foldr patt_imp (C [q]) l) ---> a ---> foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ (a ---> foldr patt_imp (C [p]) l) ---> a ---> foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, -------------------------------------- a ---> foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed (foldr patt_imp (C [p]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [p]) l, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed (foldr patt_imp (C [p]) l)
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [p]) l, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, -------------------------------------- a using gpi
mlExactn 1.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [p]) l, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l ---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [p]) l, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)
well_formed (foldr patt_imp (C [q]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l ---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [p]) l, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l ---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [p]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [p]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [p]) l, -------------------------------------- foldr patt_imp (C [p]) l using gpi
mlExactn 2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ (a ---> foldr patt_imp (C [q]) l) ---> a ---> foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, -------------------------------------- a ---> foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed (foldr patt_imp (C [q]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [q]) l, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])

well_formed (foldr patt_imp (C [q]) l)
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [q]) l, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, -------------------------------------- foldr patt_imp (C [q]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, -------------------------------------- a using gpi
mlExactn 1.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [q]) l, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [q]) l ---> foldr patt_imp (C [p]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [q]) l, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
well_formed (foldr patt_imp (C [p]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)
well_formed (foldr patt_imp (C [q]) l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [q]) l ---> foldr patt_imp (C [p]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [q]) l, -------------------------------------- foldr patt_imp (C [p]) l using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
a: Pattern
l: list Pattern
wfp: well_formed p
wfq: well_formed q
wfC: PC_wf C
gpi: ProofInfo
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
Himp: Γ ⊢i p <---> q using gpi
IHl: Γ ⊢i foldr patt_imp (C [q]) l ---> foldr patt_imp (C [p]) l using gpi
wfal: wf (a :: l)
Hwf1: well_formed (foldr patt_imp (C [p]) l <---> foldr patt_imp (C [q]) l)
Hwf2: well_formed (p <---> q)
H: well_formed (C [p])
H0: well_formed (C [q])
Hwf: well_formed (foldr patt_imp (C [q]) l)

Γ Ⱶ "0" ∶ a ---> foldr patt_imp (C [q]) l, "1" ∶ a, "2" ∶ foldr patt_imp (C [q]) l, -------------------------------------- foldr patt_imp (C [q]) l using gpi
mlExactn 2. Defined.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo

Γ ⊢i p <---> q using i → well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo

Γ ⊢i p <---> q using i → well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i

well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': ML_proof_system Γ (p <---> q)

well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': well_formed (p <---> q)

well_formed p
wf_auto2. Qed.
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo

Γ ⊢i p <---> q using i → well_formed q
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo

Γ ⊢i p <---> q using i → well_formed q
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i

well_formed q
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': ML_proof_system Γ (p <---> q)

well_formed q
Σ: Signature
Γ: Theory
p, q: Pattern
i: ProofInfo
H: Γ ⊢i p <---> q using i
H': well_formed (p <---> q)

well_formed q
wf_auto2. Qed.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
pf: Γ ⊢i p <---> q using gpi

Γ Ⱶ l-------------------------------------- C [q] using gpi → ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi → Γ Ⱶ l-------------------------------------- C [p] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
pf: Γ ⊢i p <---> q using gpi

Γ Ⱶ l-------------------------------------- C [q] using gpi → ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi → Γ Ⱶ l-------------------------------------- C [p] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi

Γ Ⱶ l-------------------------------------- C [q] using gpi → ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi → Γ Ⱶ l-------------------------------------- C [p] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ Ⱶ l-------------------------------------- C [q] using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

Γ Ⱶ l-------------------------------------- C [p] using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- C [q] using gpi )) → wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- C [q] using gpi ))) → mlTheory (Γ Ⱶ l-------------------------------------- C [q] using gpi ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- C [q] using gpi )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- C [q] using gpi ))) using mlInfo (Γ Ⱶ l-------------------------------------- C [q] using gpi )
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- C [p] using gpi )) → wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- C [p] using gpi ))) → mlTheory (Γ Ⱶ l-------------------------------------- C [p] using gpi ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- C [p] using gpi )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- C [p] using gpi ))) using mlInfo (Γ Ⱶ l-------------------------------------- C [p] using gpi )
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi

well_formed (C [p]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

well_formed (C [q])
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

well_formed (C [q])
abstract ( pose proof (Hwfiff := proved_impl_wf _ _ (proj1_sig Hpiffq)); unfold emplace; apply well_formed_free_evar_subst_0;[wf_auto2|]; fold (PC_wf C); eapply wf_emplaced_impl_wf_context; apply wfcp ).
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: well_formed (C [q]) → wf (patterns_of l) → Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

wf (patterns_of l)
exact wfl.
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i ?ϕ₁ ---> foldr patt_imp (C [p]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [p]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) <---> ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i foldr patt_imp (C [p]) (patterns_of l) <---> ?ϕ₁ using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i foldr patt_imp (C [?q]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [?q]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed ?q
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
PC_wf C
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars ?q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars ?q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
Γ ⊢i p <---> ?q using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed (foldr patt_imp (C [q]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed q
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
PC_wf C
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
wf (patterns_of l)
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)

well_formed (foldr patt_imp (C [q]) (patterns_of l))
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed p
Σ: Signature
Γ: Theory
p, q: Pattern
C: PatternCtx
l: hypotheses
gpi: ProofInfo
wfC: PC_wf C
Hpiffq: Γ ⊢i p <---> q using gpi
H: Γ ⊢i foldr patt_imp (C [q]) (patterns_of l) using gpi
pile: ProofInfoLe (ExGen := list_to_set (evar_fresh_seq (free_evars (pcPattern C) ∪ free_evars p ∪ free_evars q ∪ {[ pcEvar C]}) (maximal_exists_depth_to 0 (pcEvar C) (pcPattern C))), SVSubst := list_to_set (svar_fresh_seq (free_svars (pcPattern C) ∪ free_svars p ∪ free_svars q) (maximal_mu_depth_to 0 (pcEvar C) (pcPattern C))), KT := mu_in_evar_path (pcEvar C) (pcPattern C) 0) gpi
wfcp: well_formed (C [p])
wfl: wf (patterns_of l)
well_formed q
all: wf_auto2. Defined. Ltac2 mutable ml_debug_rewrite := false. (* Calls [cont] for every subpattern [a] of pattern [phi], giving the match context as an argument *) Ltac2 for_each_match := fun (a : constr) (phi : constr) (cont : Pattern.context -> unit) => try ( if ml_debug_rewrite then Message.print ( Message.concat (Message.of_string "Trying to match ") (Message.of_constr a) ) else (); match! phi with | context ctx [ ?x ] => if ml_debug_rewrite then Message.print ( Message.concat (Message.of_string " against ") (Message.of_constr x) ) else (); (if Constr.equal x a then if ml_debug_rewrite then Message.print (Message.of_string "Success.") else () ; cont ctx else ()); fail (* backtrack *) end ); (). (* Calls [cont] for [n]th subpatern [a] of pattern [phi]. *) Ltac2 for_nth_match := fun (n : int) (a : constr) (phi : constr) (cont : Pattern.context -> unit) => if ml_debug_rewrite then Message.print (Message.of_string "for_nth_match") else () ; let curr : int ref := {contents := 0} in let found : bool ref := {contents := false} in for_each_match a phi (fun ctx => if (found.(contents)) then () else curr.(contents) := Int.add 1 (curr.(contents)) ; if (Int.equal (curr.(contents)) n) then cont ctx else () ) . Local Ltac reduce_free_evar_subst_step_2 star := lazymatch goal with | [ |- context ctx [?p^[[evar: star ↦ ?q]] ] ] => progress rewrite -> (@free_evar_subst_no_occurrence _ star p q) by ( subst star; eapply evar_is_fresh_in_richer'; [|apply set_evar_fresh_is_fresh']; simpl; clear; set_solver ) end. Local Ltac reduce_free_evar_subst_2 star := (* unfold free_evar_subst; *) repeat (reduce_free_evar_subst_step_2 star). Local Tactic Notation "solve_fresh_contradictions_2'" constr(star) constr(x) constr(h) := let hcontra := fresh "Hcontra" in assert (hcontra: x <> star) by (subst star; unfold fresh_evar,evar_fresh_s; try clear h; simpl; solve_fresh_neq); rewrite -> h in hcontra; contradiction. Local Ltac solve_fresh_contradictions_2 star := unfold fresh_evar; simpl; match goal with | h: ?x = star |- _ => let hprime := fresh "hprime" in pose proof (hprime := eq_sym h); solve_fresh_contradictions_2' star x hprime | h: star = ?x |- _ => solve_fresh_contradictions_2' star x h end. Local Ltac clear_obvious_equalities_2 := repeat ( match goal with | [ h: ?x = ?x |- _ ] => clear h end ). Ltac simplify_emplace_2 star := unfold emplace; (* unfold free_evar_subst; *) cbn; repeat break_match_goal; clear_obvious_equalities_2; try contradiction; try (solve_fresh_contradictions_2 star); (* repeat (rewrite nest_ex_aux_0); *) reduce_free_evar_subst_2 star. (* Returns [n]th matching logic context [C] (of type [PatternCtx]) such that [emplace C a = phi]. *) (* Ltac simplify_pile_side_condition_helper star := subst star; unfold fresh_evar,evar_fresh_s; eapply evar_is_fresh_in_richer'; [|apply set_evar_fresh_is_fresh']; clear; simpl; set_solver. *) Ltac solve_fresh := (eapply not_elem_of_larger_impl_not_elem_of; [|apply x_eq_fresh_impl_x_notin_free_evars; reflexivity]; simpl; clear; set_solver) + by (unfold evar_is_fresh_in; eapply evar_is_fresh_in_richer'; [|apply set_evar_fresh_is_fresh']; clear; set_solver). Ltac rewrite_0_depths star := unfold mu_in_evar_path; cbn; repeat rewrite (maximal_exists_depth_to_0 star); repeat rewrite (maximal_mu_depth_to_0 star); repeat match goal with | [ |- context ctx [decide (star = star)] ] => destruct (decide (star = star)); try congruence | [ |- context ctx [decide (?x = star)] ] => destruct (decide (x = star)); try congruence | [ |- context ctx [decide (star = ?x)] ] => destruct (decide (star = x)); try congruence | _ => idtac end; cbn. Ltac try_solve_conplex_pile star := try apply pile_any; simplify_emplace_2 star; (rewrite_0_depths star); match goal with | |- star ∉ free_evars _ => subst star; solve_fresh | |- ProofInfoLe _ _ => try_solve_pile end. Ltac2 Type HeatResult := { star_ident : ident ; star_eq : ident ; pc : constr ; ctx : Pattern.context ; ctx_pat : constr ; equality : ident ; }. (** NOTE: with the new MLGoal_rewriteIff, we also need the variables used in the list of hypotheses (l) for the fresh name generation. *) Ltac2 heat := fun (n : int) (a : constr) (phi : constr) : HeatResult => let found : (Pattern.context option) ref := { contents := None } in for_nth_match n a phi (fun ctx => found.(contents) := Some ctx; () ); match found.(contents) with | None => Control.backtrack_tactic_failure "Cannot heat" | Some ctx => ( let fr := constr:(fresh_evar $phi) in let star_ident := Fresh.in_goal ident:(star) in let star_eq := Fresh.in_goal ident:(star_eq) in (*set ($star_ident := $fr);*) remember $fr as $star_ident eqn:star_eq; let star_hyp := Control.hyp star_ident in let ctxpat := Pattern.instantiate ctx constr:(patt_free_evar $star_hyp) in let pc := constr:((@Build_PatternCtx _ $star_hyp $ctxpat)) in let heq1 := Fresh.in_goal ident:(heq1) in assert(heq1 : ($phi = (@emplace _ $pc $a))) > [ abstract( (ltac1:(star |- simplify_emplace_2 star) (Ltac1.of_ident star_ident); reflexivity )) | () ]; { star_ident := star_ident; star_eq := star_eq; pc := pc; ctx := ctx; ctx_pat := ctxpat; equality := heq1 } ) end . Ltac2 mlRewrite (hiff : constr) (atn : int) := let thiff := Constr.type hiff in (* we have to unfold [derives] otherwise this might not match *) lazy_match! (eval unfold ProofSystem.derives in $thiff) with | _ ⊢i (?a <---> ?a') using _ => unfold AnyReasoning; lazy_match! goal with | [ |- of_MLGoal (@mkMLGoal ?sgm ?g ?l ?p ( ?gpi))] => let hr : HeatResult := heat atn a p in if ml_debug_rewrite then Message.print (Message.of_constr (hr.(ctx_pat))) else () ; let heq := Control.hyp (hr.(equality)) in let pc := (hr.(pc)) in eapply (@cast_proof_ml_goal _ $g) > [ rewrite $heq; reflexivity | ()]; Std.clear [hr.(equality)]; let wfC := Fresh.in_goal ident:(wfC) in assert (wfC : PC_wf $pc = true) > [ ltac1:(unfold PC_wf; simpl; wf_auto2); Control.shelve () | ()] ; let wfCpf := Control.hyp wfC in apply (@MLGoal_rewriteIff $sgm $g _ _ $pc $l $gpi $wfCpf $hiff) > [ (lazy_match! goal with | [ |- of_MLGoal (@mkMLGoal ?sgm ?g ?l ?p _)] => let heq2 := Fresh.in_goal ident:(heq2) in let plugged := Pattern.instantiate (hr.(ctx)) a' in assert(heq2: ($p = $plugged)) > [ abstract (ltac1:(star |- simplify_emplace_2 star) (Ltac1.of_ident (hr.(star_ident))); reflexivity ) | () ]; let heq2_pf := Control.hyp heq2 in eapply (@cast_proof_ml_goal _ $g) > [ rewrite $heq2_pf; reflexivity | ()]; Std.clear [wfC; heq2 ; (hr.(star_ident)); (hr.(star_eq))] end) | (ltac1:(star |- try_solve_conplex_pile star) (Ltac1.of_ident (hr.(star_ident)))) ] end end. Ltac2 rec constr_to_int (x : constr) : int := match! x with | 0 => 0 | (S ?x') => Int.add 1 (constr_to_int x') end. Tactic Notation "mlRewrite" constr(Hiff) "at" constr(atn) := _ensureProofMode; (let ff := ltac2:(hiff atn |- mlRewrite (Option.get (Ltac1.to_constr(hiff))) (constr_to_int (Option.get (Ltac1.to_constr(atn)))) ) in ff Hiff atn); fold AnyReasoning.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
wfp: well_formed (A <---> B)

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
wfp: well_formed (A <---> B)
H0: well_formed A

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
H: Γ ⊢i A <---> B using i
wfp: well_formed (A <---> B)
H0: well_formed A
H1: well_formed B

Γ ⊢i B <---> A using i
apply pf_iff_equiv_sym; assumption. Defined. Tactic Notation "mlRewrite" "->" constr(Hiff) "at" constr(atn) := mlRewrite Hiff at atn. Tactic Notation "mlRewrite" "<-" constr(Hiff) "at" constr(atn) := mlRewrite (@pf_iff_equiv_sym_nowf _ _ _ _ _ Hiff) at atn.
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar

well_formed a → well_formed a' → well_formed b → Γ ⊢ a <---> a' → Γ ⊢i (a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x) using AnyReasoning
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar

well_formed a → well_formed a' → well_formed b → Γ ⊢ a <---> a' → Γ ⊢i (a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x) using AnyReasoning
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

Γ ⊢i (a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x) using AnyReasoning
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

well_formed ((a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x))
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'
Γ Ⱶ (a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x)
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

well_formed ((a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x))
abstract(wf_auto2).
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

Γ Ⱶ (a $ a $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x)
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

Γ Ⱶ (a $ a' $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a' ---> patt_free_evar x)
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

Γ Ⱶ (a $ a' $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a ---> patt_free_evar x)
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

Γ ⊢i (a $ a' $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a ---> patt_free_evar x) using AnyReasoning
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

Γ ⊢i (a $ a' $ b $ a ---> patt_free_evar x) <---> (a $ a' $ b $ a ---> patt_free_evar x) using BasicReasoning
Σ: Signature
Γ: Theory
a, a', b: Pattern
x: evar
wfa: well_formed a
wfa': well_formed a'
wfb: well_formed b
Hiff: Γ ⊢ a <---> a'

well_formed (a $ a' $ b $ a ---> patt_free_evar x)
abstract(wf_auto2). Defined. (* TODO: de-duplicate the code *) #[local] Ltac convertToNNF_rewrite_pat Ctx p i := lazymatch p with | (! ! ?x) => let H' := fresh "H" in pose proof (@not_not_eq _ Ctx x ltac:(wf_auto2)) as H'; apply (@useBasicReasoning _ _ _ i) in H'; repeat (mlRewrite H' at 1); try clear H'; convertToNNF_rewrite_pat Ctx x i | patt_not (patt_and ?x ?y) => let H' := fresh "H" in pose proof (@deMorgan_nand _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H'; apply (@useBasicReasoning _ _ _ i) in H'; repeat (mlRewrite H' at 1); try clear H'; convertToNNF_rewrite_pat Ctx (!x or !y) i | patt_not (patt_or ?x ?y) => let H' := fresh "H" in pose proof (@deMorgan_nor _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H'; apply (@useBasicReasoning _ _ _ i) in H'; repeat (mlRewrite H' at 1); try clear H'; convertToNNF_rewrite_pat Ctx (!x and !y) i | patt_not (?x ---> ?y) => let H' := fresh "H" in pose proof (@nimpl_eq_and _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H'; apply (@useBasicReasoning _ _ _ i) in H'; repeat (mlRewrite H' at 1); try clear H'; convertToNNF_rewrite_pat Ctx (x and !y) i | (?x ---> ?y) => let H' := fresh "H" in pose proof (@impl_eq_or _ Ctx x y ltac:(wf_auto2) ltac:(wf_auto2)) as H'; apply (@useBasicReasoning _ _ _ i) in H'; repeat (mlRewrite H' at 1); try clear H'; convertToNNF_rewrite_pat Ctx (!x or y) i | patt_and ?x ?y => convertToNNF_rewrite_pat Ctx x i; convertToNNF_rewrite_pat Ctx y i | patt_or ?x ?y => convertToNNF_rewrite_pat Ctx x i; convertToNNF_rewrite_pat Ctx y i | _ => idtac end. #[local] Ltac toNNF := repeat mlRevertLast; match goal with | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?ll ?g ?i) ] => mlApplyMetaRaw (@useBasicReasoning _ _ _ i (@not_not_elim Sgm Ctx g ltac:(wf_auto2))); convertToNNF_rewrite_pat Ctx (!g) i end.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (b and (a or b) and ! b and (a or a) and a ---> ⊥)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ b and (a or b) and ! b and (a or a) and a ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (b and (a or b) and ! b and (a or a) and a ---> ⊥)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ b and (a or b) and ! b and (a or a) and a ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! ((b and (a or b) and ! b and (a or a) and a) and ! ⊥) using BasicReasoning
Abort. #[local] Ltac rfindContradictionTo a ll k := match ll with | ((mkNH _ ?name (! a)) :: ?m) => mlApply name; mlExactn k | ((mkNH _ _ _) :: ?m) => rfindContradictionTo a m k | _ => fail end. #[local] Ltac findContradiction l k:= match l with | ((mkNH _ _ ?a) :: ?m) => match goal with | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?ll ?g ?i) ] => try rfindContradictionTo a ll k; let kk := eval compute in ( k + 1 ) in (findContradiction m kk) end | _ => fail end. #[local] Ltac findContradiction_start := match goal with | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] => match goal with | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] => findContradiction l 0 end end. #[local] Ltac breakHyps l := match l with | ((mkNH _ ?name (?x and ?y)) :: ?m) => mlDestructAnd name | ((mkNH _ ?name (?x or ?y)) :: ?m) => mlDestructOr name | ((mkNH _ ?name ?x) :: ?m) => breakHyps m end. #[local] Ltac mlTautoBreak := repeat match goal with | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] => lazymatch g with | (⊥) => breakHyps l | _ => mlApplyMetaRaw (@useBasicReasoning _ _ _ i (@bot_elim _ _ g _)) end end. Ltac try_solve_pile2 fallthrough := lazymatch goal with | [ |- ProofInfoLe _ _] => try apply pile_refl; try_solve_pile; fallthrough | _ => idtac end. #[global] Ltac mlTauto := _ensureProofMode; unshelve( try ( toNNF; (try_solve_pile2 shelve); repeat mlIntro; mlTautoBreak; findContradiction_start ) ) .
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥ using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥ using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i b and (a or b) and ! b and (a or a) and a ---> ⊥ using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (b and (a or b) and ! b and (a or a) and a ---> ⊥)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ b and (a or b) and ! b and (a or a) and a ---> ⊥
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (b and (a or b) and ! b and (a or a) and a ---> ⊥)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ b and (a or b) and ! b and (a or a) and a ---> ⊥
(* TODO: fail loudly if there is something else than AnyReasoning *) mlTauto. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i a ---> ! a ---> b using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i a ---> ! a ---> b using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i a ---> ! a ---> b using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (a ---> ! a ---> b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ a ---> ! a ---> b
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (a ---> ! a ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ a ---> ! a ---> b
mlTauto. Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c using AnyReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c using AnyReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b) ---> (b ---> c) ---> a or b ---> c using AnyReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

well_formed ((a ---> b) ---> (b ---> c) ---> a or b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ (a ---> b) ---> (b ---> c) ---> a or b ---> c
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

well_formed ((a ---> b) ---> (b ---> c) ---> a or b ---> c)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ (a ---> b) ---> (b ---> c) ---> a or b ---> c
mlTauto. (* Slow *) Defined.
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i ! (a and ! a) using AnyReasoning
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i ! (a and ! a) using AnyReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ ⊢i ! (a and ! a) using AnyReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (! (a and ! a))
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ ! (a and ! a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (! (a and ! a))
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ ! (a and ! a)
mlTauto. Defined.
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i ! ! a ---> a using AnyReasoning
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i ! ! a ---> a using AnyReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ ⊢i ! ! a ---> a using AnyReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (! ! a ---> a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ ! ! a ---> a
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (! ! a ---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ ! ! a ---> a
mlTauto. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i ((a ---> b) ---> a) ---> a using AnyReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (((a ---> b) ---> a) ---> a)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ ((a ---> b) ---> a) ---> a
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (((a ---> b) ---> a) ---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ((a ---> b) ---> a) ---> a
mlTauto. Defined. Close Scope ml_scope. Close Scope list_scope. Close Scope string_scope.